PH热榜 | 2026-07-15

@ajaykumar1018 Super excited about this launch

@ajaykumar1018 Congrats on the launch! 🚀

I really like the shift in thinking here. The bottleneck isn't creating the video anymore, it's finding the right context to explain. That resonates with how many teams work today.

I'm curious, after rolling out Velo 3.0, what type of content has been the biggest surprise? Product demos, onboarding, internal training, customer support, or something you didn't expect people to generate so frequently?

Excited to see where you take this! 🔥

@ajaykumar1018 @grege_rodrigues I like this product and Its awesome features initially there was some issues but now It is super cool and easy to use. You guys are doing really good work and always try to make the application robust.
many congratulations for this launch!!

@sourav_sanyal Velo has been super helpful. We are now able to create video in minutes which used to take us many days.

@sourav_sanyal Looking forward to all the feedback today. That's always the best part of launch day

@jpinkman Lot's of work to make work videos

@jpinkman "AI Rewrite" is my favourite feature for creating multiple versions of a single video

@c_oglu86713 Curious, we actually let you pause on our recorder. Would love for you to try it feedback

@c_oglu86713 We actually support this today! Would love to hear how it works for your use case.

The agent understands what's happening on your screen, what you're saying, and your speaking style, then edits the video for you

@tirth_nandha1 Lessgo

@tirth_nandha1I've had a front-row seat to how much work went into this, killed it 🙌

@rituparakh Lessgo

@rituparakh Glad we finally get to share what we've been building 🚀

@zerotox Only text for now

@artstavenka1 It asks you and looks at the entire time series of all events

@hersh_singh This warms my heart

@hersh_singh This made my day ❤️, thanks for sticking with us and sharing your experience

@myrabhatia Lessgo

@myrabhatia Excited to see how people use it!

@grege_rodrigues1 Lessgo

@grege_rodrigues1 Really looking forward to all the feedback on Velo 3.0

@aymnart You could do your own voice clone and edit every single word the AI generates in the edit script. On the prompt side of things you can just direct it however you want it to be

@aymnart Yep, you can edit every word yourself or let AI Rewrite do it in different personality styles

@crystalmei thank you, today it's all three, honestly. We see teams using Velo for customer demos, internal training, onboarding, support, and product updates. The common thread is turning company knowledge into videos people can actually use

@soni_karan Lessgo

@soni_karan Excited for the feedback from users!!!!

@harshil_aru Thank you so much

@harshil_aru Glad you liked it

@mshen316 please do try and share us your feedback

@ajaykumar1018  @rohanrecommends  @harkirat_singh3777 Yes, you chat and decide the outcome you want with relevant details and then we render the video

@iamanantgupta If there's a clear distinction between them we make it, else we ask you the user

@iamanantgupta The conversation with the agent is a big part of it. It helps resolve ambiguity and frame the right story before the video gets generated

@emircan1143 Appreciate it, you should try the prompt product too. It will genuinely delight you.

@emircan1143 Thanks you so much for your feedback

@galdayan Today, it’s a snapshot accurate at generation time. The sources stay attached for traceability. We’re building source-aware freshness so when a connected doc changes, Velo can flag the affected video and update only the relevant sections.

@galdayan Right now, it's more of a snapshot at generation time, but regenerating pulls in the latest context from all your connected sources

@adem1343093 Added to feature roster. We can add this super easy

@adem1343093 We don't support it today, but I can definitely see how it'd save a lot of time

@dtanta24444 Thank you, this is exactly the bar we had in mind ❤️

@ule882420426780 Yupp, you should try it out

@ule882420426780 We support this today, please do try Velo and share your feedback :)

@shubham16180 Thank you so much!

@shubham16180 Thanks a lot!

@shubham_converse_ai Appreciate it a lot

@shubham_converse_ai Thanks you so much!

@ryker_rowan1 Yep, Velo knows when the underlying knowledge has changed and asks you to review the video before updating it.

We don't support bulk updates yet, but that's a great suggestion. Added it to our feature requests

@shekhar_upadhaya_1 Yep, fully made with Velo. We spend a lot of time making the output feel tailored to the context and audience, rather than forcing everything into the same template.

Would love for you to give Velo a try and let us know what you think

@zareen_khan6 Added to the feature requests!

@gkegn4c Thank you so much

@tammytan516 I was pleasantly surprised by what I saw, as I already think 3D is pretty cool. By the way, could you tell me which large language model (LLM) is currently integrated here? Or do we have the option to choose our own model?

@tammytan516 interesting that you call out 3d printing hobbyists. most tools in this space chase game devs only. are the exported meshes watertight enough to print without cleanup? that alone would win that crowd over. good luck today 👏

@abod_rehman Excellent question. To handle high-speed and intricate actions, we utilize our proprietary AI motion capture model. In our testing, the system performs remarkably well even with highly demanding and complex movements, such as breakdancing, maintaining tracking stability with minimal glitching. We highly encourage you to test it out on the platform to see how it handles your specific motion requirements!

@artstavenka1 Thank you so much! Regarding occlusion during motion capture, you hit on a classic challenge. To handle those moments where limbs are blocked, our AI model is specifically trained to predict and interpolate hidden joint movements, keeping the animation fluid even when parts of the body are temporarily out of sight. Additionally, in our latest update, we’ve introduced a new feature for multi-person videos that allows you to select a specific subject to target and extract motion from, making the pipeline even more robust.

Thanks again for the support and the highly professional feedback!

@artstavenka1 Thanks for noticing! Killing the "triangle soup" was a huge priority for us so these assets are actually usable.

To your mocap question: Yes! Our model understands spatial kinematics, so instead of failing during occlusion, it calculates and interpolates the physical trajectory through the blind spot.

We'd love to hear how further stress tests go!

@pan_ji1 Thanks Pan! I’ll also be here today to collect feedback from creators and answer questions around launch offers, use cases, and community feedback.

@pan_ji1 Thanks Pan! Excited to be here with the team today 🚀

@yifu_wang93 Well said! I’ll be here today collecting feedback from creators around quality, use cases, and workflow needs. Excited to see what people try with V2Fun～

@yuki1028 Yes, absolutely! The motion capture data generated on V2Fun can be easily exported to standard formats (such as .bvh .fbx or .glb).

@jocky We are actively building out more game-ready showcases! You can find diverse presets on V2Fun. We also highly encourage users to share their creations on our platform. When others download your shared models, you’ll earn points that can be used for future generations!

@junya_li 💗

@junya_li 😊

@sandy_liusy Thank you for the kind words and support! We’re highly focused on delivering production-ready quality directly in the browser. Hope you enjoy the workflow!

@boyuan_deng1 Great question! V2Fun handles rigging through a highly intuitive marker-based auto-rigging system, so you don't have to do it manually. Instead of traditional manual bone weight painting, you simply place keypoint markers onto the front and side reference views of your character. The system then automatically identifies the joint locations and binds the skeleton to the mesh in just a few clicks.

@user_haze Thanks～

@omri_ben_shoham1 Thank you for the kind words! Keeping everything in a single pipeline to stop that "handoff" quality loss was exactly our goal. Regarding motion capture, it is currently tuned strictly for humanoid characters. We are actively working on expanding this capability to animal rigs and other non-humanoid shapes.

Those features are gradually being added to our roadmap, so please stay tuned!

@omri_ben_shoham1 Thanks! That’s exactly the workflow gap we’re trying to reduce.

Right now, our mocap is mainly optimized for humanoid character motion. Non-humanoid rigs are an area we’re still exploring, and we’d love to support more creature/object-style motion workflows over time.

@ryancheng Thank you so much for the support! Eliminating that multi-tool friction was exactly our goal.

Regarding phone footage, our proprietary AI mocap model is optimized to handle rapid, complex movements very well. In our testing, it successfully tracks intense actions like breakdancing and fight sequences with clean stability. We’d love for you to try it with your own footage and see how it performs!

@thea5 Yes! We support uploading your own custom 3D models directly onto the platform to utilize our 8K texturing pipeline.

@reda_roqai_chaoui Heavy camera movement and occlusion are definitely challenging cases. V2Fun performs best with relatively stable videos, and we’re continuously improving tracking robustness for more complex scenarios.

@reda_roqai_chaoui Thanks for checking it out!

We've integrated robust tracking algorithms that offer great stability against heavy camera movement and partial occlusion. However, to be completely transparent, if the subject completely disappears from the frame, the tracking will still drop. We are actively researching how to tackle these extreme edge cases for future updates!

@luke_pioneero Thank you so much for your support! We actually have several test cases ready on our platform, and you are more than welcome to upload your own video clips to experience it firsthand. We can't wait to hear your feedback!

@shuyan_dong Thank you so much! Saving creators that tedious setup time is exactly why we built the integrated video-to-mocap feature. We can't wait to see what you create for your next animation project! Please feel free to share your work or drop us any feedback once you give V2Fun a try. Happy creating!

@new_user___1802026258df93399c32311 That is a spot-on suggestion! A dedicated 3D printing workflow is actually high on our roadmap. We are actively working on a seamless "AI design to manufacturing" integration that will allow you to generate models and send them directly to professional 3D printing software for manufacturing. We will also support exporting clean, print-ready file formats like STL and OBJ.

@charlenechen_123 Thank you so much! Hope you enjoy trying it out. We’d love to hear your feedback after you’ve had a chance to create something with V2Fun!

@galdayan Great point. This is a massive challenge across the entire Gen AI industry right now. To address this, we are actively building a dedicated IP infringement firewall system to help mitigate these exact risks. We'd absolutely love to hear your thoughts or suggestions on what would work best for the game dev community!

@aymi_malik Thanks so much! 🎉

For stylized characters, yes—the automated rigging works perfectly out of the box as long as they are humanoid. We don't support non-humanoids (like quadrupeds) just yet, but that is actively on our roadmap and will be supported in upcoming releases.

Appreciate the support! 🚀

@irahimiam Thanks! Yes, the output is designed to be engine-ready. It maps directly to standard skeletons like Unity's Humanoid and Unreal's Mannequin. You can drop the assets straight into your pipeline with minimal to no retargeting required.

@new_user___0712026671cee8595c89236 Yes! V2Fun generates editable 3D models from text, images, or multi-view references. It’s built to speed up your workflow and works great alongside Blender.

@yang_liu51 You hit the nail on the head! The friction of jumping between five different tools just to get one usable, animated character is exactly what we wanted to eliminate. We are so glad the unified workflow is clicking with you. Thanks so much for the incredible support!

@pjsu Thank you so much for your support! Here is the link：https://www.youtube.com/watch?v=9R4309075Zc

@hongyin_luo Thank you! We've actually already begun collaborating with enterprise partners on our API.

We absolutely plan to open up the API interfaces directly on our platform for everyone in the near future, making it easy to connect V2Fun to your coding agents or custom pipelines. Stay tuned!

@xinlei_niu Yes, scene generation is definitely a direction we’re interested in our current focus is characters and motion workflows first, then expanding toward richer 3D environments over time.

@xinlei_niu Yes, we definitely plan to support scene and environment generation in the future! While our immediate focus is on perfecting high-quality, game-ready characters and props, we see scene generation as the natural next step. Our ultimate goal is to evolve V2Fun beyond individual assets and into a complete spatial generation engine, allowing you to build fully textured 3D environments and layouts directly on the platform.

We are already researching and developing the foundational tech for this, so stay tuned!

@parsons_wu_real V2Fun can already help speed up the idea-to-animated-character workflow, but some manual cleanup may still be needed depending on the quality bar and use case.

@phoenixhu Yes, it’s on our roadmap, we’d love to support community sharing and discovery for generated models once the core creation workflow is more mature.

@phoenixhu Yes, we are definitely building toward that! Our current sharing system—where users can share their creations on the platform and earn generation points when others download them—is just the first step. It is the foundation of our creator loop.

@mingyouagi Thanks Ming! Yes, team accounts are something we’re planning for.

@mingyouagi Yes, absolutely! Providing team and studio accounts is a key part of our roadmap. We've actually already begun collaborating with enterprise partners on our API. We absolutely plan to open up the API interfaces directly on our platform for everyone in the near future, stay tuned!

@agreaves okayyyy but being able to execute INSIDE of Campus is actually wild.

and the gifs/memes really do pop off over here.

everyone, get your whole team to join, build, AND joke together! literal best way to do team bonding :)

@agreaves "20+ terminal tabs, Claude in one, Codex in another, rebuild context on every switch" is painfully accurate. Persistent per-project context is the right fix. Does Campus persist the agents' own history too, or just the workspace layout around them?

@agreaves Really impressive direction. I'm curious, how are you thinking about balancing AI-generated speed with developer trust? For example, are you exploring ways for builders to understand why the AI generated a particular architecture or workflow, rather than only editing the final output? I think that level of transparency could become a real differentiator.

@norbert1 emphasis on the FUN

@norbert1 Still remember the call where we saw the first demo. Campus has come so far along since that day and we should all be very proud.

@mike_diarmid1 hurray for spatial organization >>>>

@mike_diarmid1 yes the reduction in context switching cost is huge!

@micmayer LETS GOOOOO

@micmayer love to hear it, Michael! We're just getting started!

@micmayer thanks Michael! Glad you're liking it! 🙂

@suryansh_tiwari2 thanks, Suryansh! Excited to hear what you think!

@suryansh_tiwari2 thanks for the love <3

@alieksia Thanks! And yes, we noticed things cluttering up a bit if you only have a singular space with everybody on it.

For this, we created rooms - they let you organize work in multiple canvases! Besides that, rooms also act as a nice collaboration boundary. You can choose who can access rooms and collaborate with any set of people!

@alieksia great question! Like Norbert said, rooms help but also something about it being arranged in 2D makes it easier. And lastly, the whole canvas is searchable!

@vladimir_iudin yeah exactly one of the core pillars is that the agent can do anything a human can. More specifically, Campus ships with a CLI + a skill which an agent can use, so everything is just a tool call from your agent, gated by your agent's own permission management.

@shadroi it really is so fun!!

@shadroi thanks, Shad! That's what excites us as well, it just feels "right". Glad you've enjoyed it!

@1mirul 💯

We're also super excited to see what people use this for. Campus is engineered to be a sandbox for work, the rest is up to the user :)

@1mirul we are too - give it a try and let us know!

@lydia_lee3 on "in the same room" note: I really like those instant messages which you can trigger with "/". others seeing in realtime what exactly are you typing (with all the typos and backspaces) - really feels like we're in the same space not just virtually

@lesnitsky unhinged gifs are a regular occurrence fr

@lesnitsky As much as I love all the other features and benefits of Campus, the team shenanigans are my favorite part :)

@abdulsametjo5z that's a pretty compelling use-case! If you are working on a web project, the agent should be able to preview UI it built with the built in web browser!

Curious how you would envision the UX to be inside of Campus for this.

@abdulsametjo5z thanks for the suggestion, Abdulsamet!

@andrasczeizel Campus runs 'local first', meaning everybody is working on their own local files and local terminal sessions. By default terminals are view-only for team-members in the same room (think, everybody sitting in the same physical room but working on their own computers). You can however setup shared workspaces where everybody has access to terminal/files etc. for collaborating on the same files. More on this in future Campus releases! :)

@andrasczeizel Norbert gave a great answer, but "GIFs, screenshots, and quick reactions probably matter more for remote teams than people admit :)" is so true!

Once we started using it we felt instantly more connected as a team, it's almost like being in an office and feeling the "hum" of the room. Also, the easter eggs can be fun :)

@chris_at_flutterflow best products are built out of your own need!

@grace_lee26 totally - that's the goal. Give it a try and let us know what you think!

@grace_lee26 totally agree. The biggest bottleneck right now is context switching.

We're actively optimizing Campus to be equally easy to use for a human & an AI!

@grace_lee26 future-me matters SO. MUCH.

@erdem536284 hey Erdem! This particular launch is for our new tool Campus, an infinite canvas for organizing your work (possibly including FlutterFlow!). But always appreciate feedback for FlutterFlow! We're always looking for ways to improve the tool.

@ridhwikvinod this is a great question! i'm a growth lead so i know what you mean hehe

we're still in alpha, but i've found that i really love to use Campus to see what my team is building in real-time and actually build my marketing campaigns that way. so instead of having product and marketing separated in silos, there's a more unified sense of vision (and PROGRESS UPDATES)

@ridhwikvinod love this question! We initially built Campus for ourselves to make it as low friction as possible to manage our work, which also means keeping the technical barrier low. So as long as you're building with agents and want your team and other agents to share context, there's nothing stopping your whole team!

@angelaa that's what I really love about it - everything in one place. Let us know what you think!

@angelaaa thanks, Angela! It's been huge for us, so looking forward to hearing your feedback!

@ozandag Campus is built to be a sandbox. Every tile has a dedicated API for the agent to interact with. If you want agents to collaborate, just tell them! They will be able to figure out the details :)

@ozandag let us know if you have any other questions!

@alex_watson2110 agreed! We're entering an area where instead of asking 'how can we observe agents better?' we can start asking ourselves 'how can agents better surface information for us?'.

We believe an interactive canvas is a remarkable good surface for this! More exciting stuff coming soon 👀

@alex_watson2110 this ^^^ the persistent context changes everything

@alex_watson2110 yes! It felt like we were banging our heads against a wall before this

@aymnart hey Aymen! This particular launch is for our new tool Campus, an infinite canvas for organizing your work (including FlutterFlow!). Hope you can check it out.

For FlutterFlow, I'd recommend checking out our YouTube channel for tutorials on building complex apps!

@aymnart you can use FlutterFlow (and Designer) INSIDE of Campus, alongside your other agents and tools!

@elliot_zoellner ooh this is AWESOME! can't wait to hear the report :)

@alex_iliescu thanks for the love!

@madalina_barbu thanks Madalina, give it a try and let us know what you think!

@bryanlparker thanks Bryan! That's a really good point, our main focus is to improve the handoff process and make it as easy as possible for your agent to get context from you and vice-versa. But the line of where to do the handoff we don't take an opinion on (yet) and leave that to the builder since it's a personal choice how much you want to be involved.

@irahimiam thanks Arash! Work happens locally on your machine, so as long as it's awake the work continues. In my experience, the work pauses when my laptop closes but resumes as soon as I open it back up! So if I'm stepping out I generally leave it locked but open and let my agents do their thing :)

@priya_kushwaha1 Great question.

We keep the trigger path deliberately thin: an incoming event (a webhook, or a manual dispatch from Command Center) is acknowledged and the run is handed off asynchronously, so the trigger-to-execution overhead is small and roughly constant.

The latency that actually dominates is the agent loop itself: brain retrieval + model inference + tool calls. That's seconds-scale, and it's where we spend our optimization budget (prompt caching, a frozen prompt prefix, incremental cache breakpoints so repeat runs stay fast).

Happy to go deeper. DM me and I'll share the real prod numbers we're seeing.

@omarships  @priya_kushwaha1 This one's my corner 🙂 The pipeline: trigger comes in → validate + persist + hand off to a stateless agent service, all off the request path → then the loop runs (retrieval → inference → tool calls, iterating to done). We tag every stage with correlation IDs so we can see exactly where the time goes, and the trigger→handoff segment is by far the cheapest part. It's the tool round-trips and inference that set the pace. Ping me and I'll share real traces with the exact split.

@amraniyasser You just articulated our entire bet, thank you 🙏

It bends upward, and the reason is the part people miss: connecting sources is table stakes, that curve does flatten once your stack is in.

What keeps compounding is everything that happens after, every correction you make, every decision you approve or reject, every "no, do it this way." That gets encoded, so the brain stops just knowing your data and starts knowing your judgment.

That's the moat and the switching cost you're pointing at: a competitor can copy the features, they can't copy six months of your company's context and your decisions living in one place. The data is the commodity. What you've taught it is the moat.

@omarships  @amraniyasser from a more technical standpoint:

Two curves here: raw source-connection does plateau once your big tools are in, you're right.

But the graph keeps compounding on a different axis, entity resolution links more previously-siloed things over time, the temporal history deepens, and every correction or approval becomes a durable signal, so the value curve keeps bending up well past "everything's connected."

@artstavenka1 Appreciate it and definitely the right question 🙏

The way we see it: your company's brain should understand that reality changes, not just pile up facts. A customer isn't "active" forever, they're active until they churn. A deal doesn't sit in one stage, it moves. So the brain doesn't keep the new note next to the old one and shrug. It understands that "churned" replaces "active" because they can't both be true, and it remembers exactly when that flipped. You get the current truth and the history of how you got there. That's the difference between memory and a filing cabinet. Ahmad will give you the actual mechanics 

@artstavenka1 Thanks Omar. So conceptually Omar's answer will be easier to understand but here's a more technical breakdown.

Here's the mechanic. Staleness isn't a timer or "newest overwrites," it's contradiction detection at write time. When a new fact comes in, we check whether it conflicts with an existing relationship. "Customer churned" contradicts "customer active," and a deal has one current stage, so those old edges get invalidated (we stamp them with an end time rather than deleting them). Additive facts that don't conflict, bought product A then product B, just coexist. So invalidation is semantic, not chronological: mutually-exclusive states supersede, independent facts accumulate. And because it's bi-temporal, you can still ask "when were they active" and get the exact interval. Honest caveat: the contradiction call is model-assisted, so clean state transitions are reliable, and for genuinely fuzzy ones we keep both and lean on recency + provenance instead of forcing a merge.

@alex_iliescu only one way to find out 👀

@himani_sah1 Great question, Himani — it's the part we obsess over most. Two separate problems, handled separately:

Accuracy — agents don't answer from vibes. Everything is grounded in your company brain (a temporal knowledge graph of your docs, CRM, Slack, tickets), and retrieval is a cited lookup — the answer points back to the actual source, and the graph knows what was true when, so stale facts don't leak in. And for anything that changes a system of record, the agent doesn't fire blindly: it produces a drafted, context-aware proposal that waits for your yes. So accuracy failures surface as "here's what I'd do" before they become actions.

Permissioning — three layers. (1) Everything is scoped to a workspace — data and connections are isolated per tenant, never shared across. (2) Tools connect via OAuth, so the agent only ever acts within the scopes you actually granted — revoke the connection and it's gone. (3) Writes go through an allowlist of validated actions, gated by a policy layer + a kill switch, and every action is logged to an audit trail. Nothing runs outside that boundary.

Short version: read broadly, cite always, and act only through a narrow, approved, audited door. Happy to go deeper on any layer 🙌

@himani_sah1 Accuracy comes from the brain, everything's grounded in your real source data, stale facts get superseded instead of lingering, and weak or conflicting signals get flagged, not guessed. Permissioning is by design, not trust: agents only get an allow-listed set of actions per tool, and anything consequential waits for your sign-off.

@duyk_me Appreciate you Duy

@duyk_me Thanks for the support

@ahmadhajj  @anna_ludwinowski  

On the ideal user, everyone who is using AI for work can and should use it. In our Cohorts, we had solo founders, small teams, mid sized startups, mid market companies, VC's even and 1 FAANG Enterprise.

The real question is, who benefits the most: today it's the lean operator, solo founders and small teams (think under ~20) who are drowning in tools and feel the coordination tax hardest. Big teams benefit too, but that's where the pain is sharpest and the "oh, I don't have to be the glue anymore" hits fastest, so that's who we build for first.

On first relief: exactly the loop you liked, the moment a signal in one tool becomes handled work in another without you shuttling between tabs. A failed payment that turns into a drafted, context-aware follow-up and a Slack heads-up, waiting for your yes. First time someone watches that happen, the relief is physical.

Really appreciate you 🙌

@omarships  @anna_ludwinowski Thanks Anna 🙏 — You're right that we should lead with the Stripe → Slack → Linear moment; it's the clearest picture of the actual problem: today you're the glue between tools, and that coordination tax is invisible until someone removes it.

Omar nailed the who and the first-relief, so I'll just add the part that makes it safe to love: every one of those cross-tool actions comes to you as a drafted, context-aware proposal waiting for your yes — nothing fires blindly. You get the relief of "handled" without giving up control. That's the line we're building everything around.

Really grateful for the thoughtful questions 🙌

@swati_paliwal Great question, and it's the line between a demo and something you'd actually run a team on.

Accountability is first-class: every action carries who proposed it (which agent), who approved it (which human), the reasoning, and the context it pulled from, so "who decided this and why" is never a mystery, it's on the record.

On rollback: anything reversible has a full trail and you can course-correct, but for irreversible actions we deliberately put the control before the action, not after, because you can't cleanly undo a sent email or a charge. Ahmad can walk the audit mechanics 👇

@swati_paliwal On the mechanics: every action writes an audit record with the actor (the specific agent run, or the human approver), a timestamp, the reasoning, and the exact context it pulled from the brain, all traceable end to end by correlation ID across the tools it touched. Because we approve-and-replay, the executed action is provably the one a named human signed off on, no drift between "approved" and "ran."

On rollback and reassign, I'll be precise rather than oversell: reversible actions have a trail you can act on, reassigning ownership routes through the same task/approval layer, and for irreversible side effects the real control is the pre-execution gate. We prevent instead of promising a rollback physics won't allow.

@yahia_bakour3 Thanks Yahia, appreciate the support! 🙏

@yahia_bakour3 Appreciate you Yahia, one step closer to figuring out AGI. Only saying this to raise an anthropic sized round, hopefully they dont see this

@medal411 You've nailed the exact hard case, and honestly it's the line between a toy and a system: a one-way feed whose own clock you can't trust, out-of-order amendments, and corrections superseding corrections.

Short answer: we don't take the source's self-reported time as ground truth, and we don't collapse it into ingestion order either. It's bi-temporal, so both are first-class and stored separately. The source's reported time is treated as a claim (an attribute of the event), and our ingestion order is always retained independently, which is what lets the two disagree without forcing a destructive pick. When a correction supersedes a correction, each one invalidates the prior with a validity interval, so the lineage stays intact even when they land out of order.

Where I'd rather be precise than hand-wavy: for a feed like SAM.gov, where the timestamp itself is unreliable, the right reconciliation isn't a global rule, it's source-specific logic in the adapter. That's where you'd encode "order on the amendment/version sequence, not the reported clock," since those postings usually carry a monotonic version that's safer to trust than the timestamp. Some of that is turnkey, some we'd tune for your exact feed, and I'd rather scope it with you than oversell one answer.

Genuinely a fun problem. DM me and let's go deep.

@medal411 Ahmad gave you the how, here's the principle: a source's clock is a claim, not the truth, so the brain reconciles reality rather than trusting whatever landed last. For a feed as adversarial as SAM.gov that's not a generic setting we'd flip, it's something we'd tune with you. Genuinely our favorite kind of hard, let's get into it.

@muhammadtanveerabbas Thank you 🙏 Two layers keep it honest. The brain doesn't just stack facts, it understands state changes, so for example "churned" replaces "active" and the stale version stops driving decisions. And since nothing consequential runs without your sign-off, even if something outdated slipped through, it surfaces to you before it acts, not after. It remains a ultimate source of truth

@muhammadtanveerabbas Thanks so much — really appreciate you zeroing in on the context layer, that's the part we care most about too. 🙏

On keeping shared memory accurate: a few things do the heavy lifting. Every piece of context is timestamped and tied to its source event, so nothing floats around as free-standing "facts" — it always knows where a memory came from and when. Newer signals supersede stale ones, and anything that hasn't been reinforced decays in weight rather than lingering with full authority. When two sources conflict, we surface the conflict instead of silently picking a winner, so a decision never quietly rides on outdated info.

Still plenty to sharpen here as we scale, but that's the core of how we stop old context from steering new decisions.

@muhammadtanveerabbas Mechanically it's a temporal graph: contradicting facts invalidate the old version (with a validity interval, not a delete), and retrieval favors current, provenanced context over stale. So outdated facts don't quietly leak into a decision, they're either superseded or visibly flagged as old.

@nicklaunches  Thanks 🙏

On messy: when signals are weak or conflicting, it degrades to asking, not guessing, so bad input never becomes a confident action.

On growing: connecting sources is table stakes, but every correction and decision you make gets encoded, so it keeps getting sharper long after your stack is wired up.

@nicklaunches Messy: we link on hard signals (shared IDs/domains), and when a match is weak we flag instead of forcing it.

Growing: as more episodes land, the graph's relationship density climbs and every human correction becomes a durable signal, so the curve bends up past "everything connected." It's not just more data, it's more resolved connections.

@dmitrii_tolstikhin The data is coming straight from stipe and slack, the brain makes correlations based on how the data relates to each other through normalization, algorithms and embedding. The brain goes through a series of processes including validation and invalidation. Jarvis does not have access to the brain to act its own. In any case, the last de-risk attempt we integrated is -> you review before it lands, you never find out from the logs, and nothing hits Stripe until you say yes. We gate before the action instead of promising undo, because you can't cleanly un-charge a customer, so billing stays in the always-approve bucket until you decide otherwise.

@dmitrii_tolstikhin Quick correction on the mechanics: ingestion, normalization, and embedding happen in the brain as a separate layer, so by the time Jarvis touches a Stripe event and a Slack thread they're already resolved into one grounded context built entirely from your source data, not stitched together at action time. Execution then sits behind an approval status no task passes without your sign-off, so even a bad read can't become a bad action, it stops at the gate.

There are such a thing as recurring tasks and skills (patterns your brain recognizes from your data then makes them into automated workflows). Those you approve and audit once under your own tolerance, then you don't need to going forward.

@karimbenkeroum your the best, thanks

@karimbenkeroum Mailwarm definitely needs agently.

@dhiraj_patel5 The architecture does not allow for it. The subagents are spun up based of the task that needs to be done. Jarvis injects the context into them and details the role and desired objective.

@dhiraj_patel5 Routing always resolves, because Jarvis dynamically spins up a subagent for the task instead of matching against a static set, so "no agent fits" isn't a failure state. Confidence gating lives at the subagent's actions, not the routing, high-confidence reversible work runs, anything ambiguous or consequential routes back to you.

@aymnart Actually Great question (might give you the award), and the honest answer starts with humility: you can't wrap 100 third-party systems in one clean transaction, and any tool claiming to is lying to you. So we designed for the real world, where retries, duplicates, out-of-order events, and half-failed syncs are the normal case, not the exception. Every write is idempotent, so a flaky webhook firing three times still lands once. And we reconcile truth by when things actually happened, not when they showed up. The payoff for you: a network blip or a connector hiccup never corrupts your brain which remains the source of ultimate truth, it just converges on the right picture once things settle. Ahmad can take you under the hood 👇

@aymnart Here's the mechanic. Consistency across connectors is eventual, not transactional, we don't pretend to two-phase-commit across Stripe and Slack. What makes it safe:

Idempotency — every synced record is keyed by (connection, source-record-id) with a uniqueness constraint, so at-least-once delivery from retries or failures collapses to exactly-once effect. Replays are free.

Failure handling — sync writes run off the request path, each tracked by a status column, so a failed or partial sync is observable and retryable instead of corrupting state. Webhooks ack fast, then process async.

Ordering + conflicts — writes carry an explicit reference time, so concurrent updates reconcile by when the event actually happened, not arrival order, and conflicts resolve through the temporal graph (contradiction detection + validity intervals), not last-write-wins.

So the model is idempotent ingestion + temporal reconciliation. Boring on purpose, because boring is what survives 100 flaky APIs.

@anas_chhilif Thank you 🙏 and yes, closing that loop end to end is exactly the unlock. The babysitting between tools is the tax nobody talks about. On the ambiguous next step: a good chief of staff doesn't freeze, and doesn't wing it either. They come to you with "here's what happened, here's what I'd do and why, here's the call I need from you." That's the behavior we built. When the move is obvious and reversible, Jarvis just does it. When it's genuinely a judgment call, it brings you the decision with its reasoning instead of guessing, and it gets sharper at your judgment the more it watches you make those calls. Rooting for you too 🙌

@anas_chhilif Ambiguity is confidence-gated. Every proposed next step carries a confidence signal from the brain context. High confidence + reversible, it executes. Low confidence or high stakes, it doesn't pick blindly, it generates the candidate next steps with its reasoning and routes them to you as a decision, same surface as the consequential-action gate. The part that makes it improve: it factors in how you've handled similar situations before, so "ambiguous" shrinks over time. What it'll never do is manufacture a "right" step to look autonomous. Ambiguity resolves to propose-and-defer, not guess-and-ship.

@galdayan Sharpest question in the thread shows that you have been reading up. It's the one most tools get wrong: governance has to be recursive. A gate anyone can quietly widen isn't a gate, it's a suggestion. Our stance is that changing the rules is itself a consequential action. It should be permission-gated, logged with who changed it and when, and loosening a limit should take the same kind of sign-off as the actions it governs, not a solo Friday toggle. I won't overstate exactly where every piece is today vs on the roadmap, but this principle is non-negotiable for us, and you just described the precise failure mode we're building against. Grateful you pushed here 🙏

@galdayan Congrats on the launch! From a product strategy perspective, which user segment is showing the strongest pull today. solo founders, early-stage startups, or larger cross-functional teams? I'd be interested to know where you've seen the clearest product-market fit emerge during beta.

@bengeekly I hope someone would say that. This was a placeholder video, more of an Add, the actual video didn't end up done in time.

Honest answer: today it's managed. We run on a mix of models and keep the whole system tuned around them so it just works. That's on purpose and ties straight to the "agent is the commodity" idea, the model is the layer we think you shouldn't have to babysit, so we manage it and keep it current for you. The brain, the part that's actually your moat, is 100% yours.

We have had 290 teams use it in private betas, some of which also requested opening it up to both BYOK and self hosting. Mainly enterprise for the obvious reasons, happy to have a conversation around it. DM me

@bengeekly On the eng side: today it's managed, not BYOK. The reason is reliability, we tune the agent loop, prompt caching, and tool-use behavior around specific frontier models, and swapping in an arbitrary one changes how all of that behaves. We do have per-agent model selection internally (different jobs get different models), so the plumbing for choice already exists. BYOK and self-hosted are architecturally doable and a legit enterprise/on-prem ask, we just haven't exposed them yet, because we'd rather ship one stack that's rock-solid than a dozen that mostly work. If you've got a specific model or a data-residency constraint, happy to scope it with you.

@abod_rehman Thank you 🙏

"chatbot with extra steps" might become our tagline.

The first workflow is almost always the recurring, boring, high-context one, the thing that quietly eats your Sunday. Weekly updates for the team or investors, personalized cold outreach, a competitor or account teardown.

It's the work that needs your whole company's context but not your genius, which is exactly what the brain unlocks. Once that one lands, people get bold fast. What's the one eating your week?

@abod_rehman From the eng side there's a reason it's usually those: the first workflow people trust is read-heavy. Pull context from the brain, synthesize, draft. No consequential action, so nothing needs sign-off, which makes it the perfect on-ramp, real value at zero risk. It also stress-tests the brain in the best way (retrieval + cross-tool linking) before anyone hands it anything irreversible. So teams start with "summarize and draft," then graduate to "go do it" once they've watched it be right a few times 🔥

@erkanaltnbkaas Good news: the enforcement layer this needs already exists. Every tool call runs through a policy gate before it executes, so "this action requires a human" is already how we stop consequential stuff from shipping. What you're describing is making that gate conditional on the tool's inputs (amount > $X, refund on an enterprise account, more than N per day → require approval). That's a policy predicate, and it's exactly the layer we're building user-facing rules on top of. The rails are there, we're putting the dashboard on them. Sharp spec 🙂

@erkanaltnbkaas You basically just described our philosophy back to us, so this is a yes. You draw the line, and it shouldn't be a blunt on/off, it should be conditional. "Handle refunds under $50 on your own, ping me above that" is exactly the kind of rule we want in your hands. The point of Agently isn't maximum autonomy, it's autonomy you're never surprised by. You won't get blindsided by something big, because you decide what "big" means. Thank you for putting it so clearly 🙏

@saadetpz2y That auto-linking is entity resolution on hard signals (shared email, domain, IDs), so it connects the same customer/thread/ticket across tools with zero setup. For the messy stuff the rule is: degrade to asking, not guessing. Strong signal it acts, weak or conflicting it flags and defers to you instead of forcing a match. Edge cases get surfaced, not papered over.

@saadetpz2y Appreciate that 🙏

Here's the belief behind it in a less technical manner: messy context isn't an edge case, it's the normal state of every company. Tools disagree, data goes stale, half of it lives in someone's head. So we made a deliberate call early: the system should be honest about what it doesn't know rather than confidently wrong.

Sounds small, but it's the whole product. The fastest way to lose a founder's trust is one confident action taken on bad data. So when context gets messy, Agently narrows down and tells you instead of guessing and shipping. We'd rather look a little less magic in that moment and earn the right to run more of your company over time.

The "freaked me out in a good way" part is the payoff of getting the boring foundation right. Glad it landed 🙌

@busmark_w_nika Thank you 🙏

The Trello-familiarity is intentional, we wanted the surface to feel obvious on day one.

But the board is just the window. Underneath it is a company brain that ingests your whole stack, plus agents that actually do the work: they pull the context, draft the deliverable, run it across your tools, and drop it back for your sign-off. So"Trello for agents" + a board that fills and clears itself.

Really appreciate it, GL right back 🙌

@busmark_w_nika Hahaha, love it. From where I sit it's almost the inverse of Trello: the board isn't the product, it's the control surface over an actual agent runtime. Every card is a real run with governance behind it, an approval queue and audit trail, and the agent proposes then waits for a human on anything that ships. The automations aren't bolted onto a board. The board is a window into the execution layer. 🙌

@suryansh_tiwari2 Thank you, this genuinely made our day 🙏

You captured it perfectly.

The way we think about it: the agent is the commodity, the brain is the moat. Agently pulls your whole stack into one living temporal company brain, so Jarvis (our orchestrator) never knows your company better than even your cofounder. It cross-references that context, drafts the real work across your tools, and opens it for your sign-off before anything ships.

And the brain compounds the more you feed it, so it gets sharper and more yours over time. That's the part we're most excited about. Grateful for the support, especially today 🚀🔥

@suryansh_tiwari2 Appreciate it 🙏 The part I'm proudest of on the eng side: agents don't get your company stuffed into a giant prompt. The brain is a temporal knowledge graph, and retrieval is a tool call the agent makes when it needs something. So it stays grounded, doesn't blow the context window, and can reason across tools without hallucinating the state of your company. Genuinely fun to build.

@omarships Looks super cool. Will give it a try!

@omarships Super excited for this launch. First company of its kind

@doganakbulut Agently runs on Claude (Anthropic's Opus 4.8), and we match the right model to each job under the hood — so you don't have to pick or wire anything up.

Curious though: is model choice something you'd want to control, or more a "just make it work" thing for you? 🙌

@zvonimir_sabljic1 appreciate it legend!

@irahimiam The key is that agents don't get root access to your tools. On every connector they get a defined, allow-listed set of actions, not free rein, so "100+ connectors" never means unbounded power across 100 systems. Within that, anything consequential like issuing a refund sits behind your approval by default: the agent flags it with its reasoning and waits, while low-risk read/draft work runs on its own. Control is by design, not by trusting the model to behave. Ahmad can go under the hood 👇

@irahimiam Mechanically it's two layers. First, capability is bounded: each provider has an action catalog that's an explicit allowlist with schema validation, so if an action isn't in the catalog, the agent can't call it, full stop. The surface across 100 connectors is defined, not open-ended. Second, within what's allowed, a policy gate classifies each call before it runs, consequential actions like refunds route to human approval by default (and you set the conditions, e.g. auto under $X), while reversible ones execute autonomously. It's enforced in the runtime, not asked of the prompt, so "issue vs flag" is a rule, not a hope.

@shekhar_upadhaya_1 Fair — a 60-sec demo picks "entertaining" over "exhaustive." 🙂 The short version: Agently builds a company brain from your docs, CRM, Slack, tickets, etc., then puts agents on top that take real actions in your tools — grounded in that context, so drafts and answers cite the actual source instead of guessing.

Concretely:

- Sales — spot which HubSpot deals went quiet and why, then draft personalized re-engagement in your buyers' own language.

- Support — triage an Intercom inbox and post replies grounded in your help docs.

- Eng ops — turn a Slack bug thread into a labeled, assigned Linear/Jira issue with repro steps.

- Research — "what did we decide on pricing last quarter?" → cited answer from your real Notion/Drive, not a hallucination.

- Recurring work — save any of these as a one-click private skill.

Reads across ~20 connectors (Slack, HubSpot, Notion, Intercom, Linear, Jira, GitHub, Stripe…) and writes back to many too.

Happy to run a live example on a workflow you care about — tell me your stack.

@shekhar_upadhaya_1 ill give you the answer from another pov.

The hard part for a normal assistant, and the easy part for Agently, is connecting signals across tools and moving the work forward:

• A key account's usage dips in your analytics, their champion goes quiet in Slack, and a support ticket's been open in Linear for a week. Agently connects those three into one "this account is at risk" flag, drafts outreach that references the actual open ticket, and routes it to the owner. Nobody had to notice the pattern.
• A lead fills out your form. It enriches them from the web and your brain (already in the CRM? attended a webinar? at a target account?), drafts a first reply that says why they're a fit, and routes it to the right rep, before they close the tab.
• After a customer call, it writes the recap, then actually creates the Linear tickets, assigns owners, and books the follow-up, holding anything customer-facing for your approval.

The pattern: it's not answering a prompt, it's watching your tools, connecting dots a human would miss, and moving work forward with your sign-off on anything that ships. Want me to pick one and show it live?

@ahmadhajj  @kate_ramakaieva Great question, and it's exactly why the brain is a temporal knowledge graph and not a vector dump.

We don't do "latest tool wins" or silently overwrite. Every fact lands with a timestamp and its source, so when two tools disagree, both are kept, with provenance and when each was recorded. Resolution is temporal first: newer information supersedes stale facts, and the graph invalidates the outdated version instead of pretending it never existed. Recency and source both factor in.

And when a conflict is genuinely ambiguous, the agent surfaces it instead of guessing: "these two disagree, here's each side and when." Which ties back to the sign-off model, you resolve reality, it acts on it.

So conflicts aren't resolved by hiding them. They're resolved by remembering everything, when it was true, and where it came from.

@omarships  @kate_ramakaieva This is my favorite part 🙂 Under the hood it's bi-temporal: every fact carries when it happened and when we ingested it as separate axes, so "my CRM updated late" and "the thing actually happened Tuesday" don't get confused. Writes are idempotent per source record, so re-syncing a tool doesn't spawn phantom conflicts. When new info contradicts old, we invalidate the specific relationship rather than deleting history, and retrieval is a query over that graph, so the agent pulls a resolved current view but can still see the contradiction and its provenance. For genuinely ambiguous cases we flag, we don't auto-merge and hope.

@nithish_a1 I'm curious, as AI agents increasingly rely on real-time search, how are you thinking about balancing freshness with trustworthiness? Are you exploring confidence scores or source-quality signals that developers can use when deciding how much their agents should rely on a particular result? I think that level of transparency could become a major differentiator.

@nithish_a1 "A 3-month internship doesn't count as PCB experience" becomes a rule Claude actually remembers. 700 profiles down to 50 worth calling, a full day of sourcing in 2.5 hours. Taste, finally, as an asset instead of a bottleneck.

@nithish_a1 Hey; this sounds powerful. Curious: how do you surface and explain the specific judgement signals your Claude-skill used for each ranking? Also, how easy is it to transfer or share a recruiter’s “taste” between teammates or clients without leaking that person’s private rules?

@ferdi788603 That's a great idea Ferdi, thank you! Will pass this on to the team!

@ferdi788603 Hey Ferdi, this is now possible! You can get an API key with free credits and test out the entire workflow without having to commit to anything!

@himanshi_kum563 Exactly Himanshu. Recruiters can literally clone their judgement with our skills in Claude. That's something that can't do with other saas tools right now.

@aymi_malik Hey Muhammad, from our experience it does a pretty good job of adapting to different roles with different requirements, but the quality of it lies in the feedback the recruiter provides to the models. The better the feedback, the quicker and the better results they get!

@maurya_abhiranjan We get data from across the web for candidates. Any place where folks list their work history, their work, research papers - we get it from there. And we keep pulling this data from the web in real-time, hence the candidate data is always accurate.

@carin_gan Thanks so much, Carin - we're so glad to hear this incredible feedback! 🙏

@suyash_kr  Hey Suyash, there's no fixed number! It gets better with every search since Claude keeps the context. The better the feedback you give it, the faster it calibrates!

@praveen_baraik Yes it does! There's a contact enrichment skill that does exactly that!

@nithish_a1  @abhiranjan_mehta Great question! Eastern Europe and LATAM are both well covered (part of the 1b+ profiles we currently have)

Give it a shot and let us know how it holds up against what you've tried before!

@martin_tanner  Hey Martin, thanks for the thoughtful question! Our candidate data comes from the open web, places where people publicly list their own work history, projects, research and so on.

@singh_ankit2 You can connect it to any tool that can connect with Claude. Email and Slack are possible and some of our users connect it so Claude can derive insights from their conversations there

@omri_ben_shoham1 Let's get you using it Omri! Would love your feedback to make this better!

@dominique_kimbrough Thank you so much for this incredible testimonial 🙏 it's been great seeing how far you've taken Crustdata across all your searches, and reading how you use it teaches us something about our own product every time 🚀

@manjeet_kumar25 Congrats-back and good question 🙏 We have all major ATS as well very niche solutions integrated! Ashby being one of them!

@etiennegarcia Thanks Etienne! Yes we want this to be customized to each recruiter and how they think. This is just not possible with another out of the box SaaS tool

@iamarsenibragimov Thanks Arsen for the incredible Feedback! Glad you are happy with using Crustdata!

@omri_ben_shoham1 Hey Omri, yes you can ask the summary of preferences and it will provide you with what feedback you've given and how it's understood your preferences.

@himanshu_kumar_mehta Thanks Himanshu for the great question! We offer a free trial before you having to make any Commitment!

@himanshu_kumar61 It runs on either! What we usually recommend is using Claude Code since you have more freedom and can expect faster results.

@ravinath_mahto1 We offer a "Watcher API" within the Skillset! It's part of the custom Skill and you can watch any list of companies or, if you're not sure about the companies, any filter that you have in mind!

@manjeet_kumar_mehta3 Great question! Each recruiter can train their own version, the system learns how you personally evaluate candidates, so all 5 of you can rank differently and it adapts to each of you rather than forcing one shared model. Give it a try with the team and let us know how it feels!

@alex_watson2110 As long as you provide the reasoning behind your decisions as context, the only limiting factor is your creativity! You can get as creative as possible and Claude will take that into account and run the search in the way that you want.

@nithish_a1  @lakshya_singh Thanks Lakshya!

@samirrashed Thanks Samir!

@virko_kask Hey Virko, our approach is to not rank on how the resume reads at all, we look at the verifiable footprint behind it. Work history, real projects, research papers, job changes and more across the web.

@jackcollinshq I like the shift from reactive AI assistants to proactive AI teams with defined responsibilities. The idea of giving agents guardrails, reviewing their work, and gradually increasing their autonomy based on a proven track record feels much closer to how real teams operate. Drafting a team from a company URL is also a great way to lower the barrier to getting started. Best of luck with the launch!

@jackcollinshq I’m really curious about the “every correction teaches it” part. What actually happens after I edit or reject something? Does YAGNI save it as memory, turn it into a rule, or use it in some other way? And how do you avoid teaching the agent the wrong general lesson from one very specific case?

@jackcollinshq Congrats on the launch! Looking ahead, do you see YAGNI evolving into a platform where organizations can build custom agent teams with department-specific memory and governance, or do you envision a more opinionated operating model? That roadmap choice feels really interesting from a product perspective.

@mitch_belsley1 This is the best kind of hard question, because you're right that a single Number plus clean Receipts is exactly where Goodhart creeps in. Let me split it into the part we structurally prevent and the part that's still a human's job, because I'd rather be straight than pretend we've closed the whole loop.

What we prevent: a Team cannot change its own Number, or what counts toward it. The definition is human-owned. An agent has no way to quietly redefine "qualified" from "took a real sales call" to "opened an email." That change is a deliberate human edit, not something a Team can propose or drift into on its own. So the specific move you're describing, a Team loosening its own bar over time, is blocked at the structural level. The goalposts aren't the agent's to move.

Where the judgment still lives with a human: watching whether the Number is still predicting the real outcome. If booked meetings climb while closed deals stay flat, that divergence is exactly the thing a manager should be looking at, and today we deliberately keep that read with the person, not an automated scorer. What we give them to do it well is Receipts, which verify that concrete things actually happened (a reply landed, a payment posted, a deal stage moved) instead of trusting that the work got done. Tying those downstream receipts more tightly to the Number, so the metric has to keep earning its status as a good proxy, is exactly where this goes next, and honestly you've framed the reason for it better than our own notes do.

So: the agent can't move the goalposts, and whether the goalposts still point at reality is a call we keep with the manager, backed by verified receipts rather than vibes.

Appreciate you pushing precisely where it matters - let me know if I can add more context!

@priya_kushwaha1 Thank you so much! Right now we are hosting our own as well as using US-hosted providers like Fireworks.ai and Together.ai for the open-weight model inference.

We can offer BYOK for those who want to manage their own LLM inference, and happy to support private cloud setup for compliance as well!

Let me know if you have any other questions - and thanks again!

@omri_ben_shoham1 Good scenario, and it really splits into three questions: can you see the rule firing, can you roll it back, and do you have to be the one who notices.

Seeing and rolling back: yes to both, and they're easy. Every rule is plain-language text in the Team's playbook, and each one carries its own track record, how often it was in play and whether the work under it got approved clean, edited, or undone. Retiring one is a single action that takes effect on the next run, and it's append-only and reversible, so you can pull a rule and reinstate it later without losing anything.

The trace-back is mostly automated, which I think is the part you're really asking about. When the Team drafts something, we fingerprint which rules were in context for it. So when an output later gets edited or reversed, that correction is already linked back to the rules that shaped it, you're not hand-tracing "which rule caused this." A rule that starts correlating with reversals gets proactively flagged for retirement, with its record attached.

The honest limit is the one baked into your example: that flag is driven by correction signals. For an edge case nobody has hit or corrected yet, there's no signal, so nothing can pre-detect it, you can't catch an error the world hasn't produced. What the system does is compress the loop once the first bad output surfaces: the offending rule is already in frame, and repeated hits escalate it from "here's a candidate" to an automatic retirement suggestion. So you're not reverse-engineering from scratch, but you are still the one who catches the first miss.

Thanks for the thoughtful question, and please let me know if I can add any more context!

@stacywycof83995 Really like the read-only reframing. "Earn the right to state something as fact vs flag it for review" is its own ladder, and arguably a harder one, since a wrong fact does its damage silently where a wrong action at least tends to leave a mark.

On miscalibration: the cases I care most about aren't the ones you catch late, they're the ones you design so trust can never reach them. Because reversal is a lagging signal by nature, we treat some categories as permanently past what earned trust can buy: anything irreversible with wide blast (moving money, a broadcast send, a delete) stays human-approved no matter how clean the record. The honest answer to "where does the reversal come too late" is that for those classes we assume it always does, and never let a track record buy its way past them.

For your side, that's the transferable bit: reversal is a backstop, never the primary guard for anything whose damage lands on the first instance. The read-only analog is that some claim types should never be auto-stated as fact regardless of track record, because a confident wrong assertion harms on first read, before any correction fires. Match the ceiling to how recoverable the mistake is, not to how well the agent has behaved. Would genuinely like to compare notes as you push on this.

Thank you for your thoughtful question!

@jernej_jan_kocica Great insight and thank you for the thoughtful question.

First of all, the Teams start in the "Training" phase. The success signal is never the agent grading itself, and it's never the absence of a complaint. Closed ticket and no-complaint are explicitly not counted as wins that count towards promotion to the next "Supervised" authority. At the start it's simple: a new Team drafts everything for review and ships nothing on its own, so early on you're looking at each run, not a proxy.

But I think your point is that, once it's running in Supervised or Autonomous, how do I really know it's doing the right thing?

Receipts are at least a partial answer here... a verified record that a concrete thing actually happened, written back onto the source record itself, the ticket or the contact, not a side dashboard. So the proof of a run lives where the work lives. And if something looked fine but proves wrong later, undoing it claws back the trust that run earned rather than leaving the record falsely clean.

Above the per-run layer, the briefing is the top-level review: a periodic roll-up of what the Team did and what held, so someone is reading the forest, not just approving trees. And all of it is interrogable in the YAGNI chat, you can just ask a Team about any run and pull the receipts.

The one thing I won't oversell: turning a week-later reopen into an automatic score is genuinely hard, and no system invents a signal reality doesn't emit. What we're careful about is never reading silence as success, which is the exact failure you're describing.

If you're up for it, I'd love to discuss this workflow more deeply with you to make sure we have the right "Trust" posture for the Autonomous workflows.

Thanks again for the great question!

@aaron_stachel Thank you Aaron, means a lot to have you watching this go live!

You've put your finger on the whole bet. The single-user assistant part is getting commoditized fast, and it was never the hard problem. The hard problem is the org layer: shared context, guardrails that hold, and memory that accumulates across a team instead of living in one person's chat history. That part is genuinely tedious to get right, which is exactly why we think it's worth building and defensible once it exists.

And the "start fast, train over time" arc is the thing I most wanted to be true. You shouldn't have to configure trust up front, because nobody actually knows what to configure on day one. You get going in minutes, and the system earns its way into more responsibility off a real track record. Fast to start, slow to fully trust, and honest about the difference.

Grateful for the backing that let us take the harder path here. More soon!

@tiffany_korths So glad to hear that! I really appreciate it Tiffany!

@xueyanzhang Thank you, that's exactly the intuition we were hoping would land. The recruiting step isn't just onboarding UX, it's doing real work. Before you hand an agent anything, you're deciding what it's responsible for and where it fits. That framing is what makes everything after it make sense: an agent with a defined role can earn trust in that role, the same way a new hire earns it on their actual job, not in the abstract.

And you put your finger on why we avoid the "all-star AI team, just add water" pitch. Nobody manages that way with people, and it's not how trust actually forms. You bring someone in, you give them something small, you see how it goes, you give them more. The ladder is just that instinct made explicit, so the trust is legible instead of a leap of faith.

Really appreciate you seeing the intent here. Let me know if you have any other questions!

@andrewzakonov Yes, a Team can drop back a rung. Here's how it works: once a Team has earned some autonomy, it can do certain things on its own without waiting for you to approve each one. If it does something on its own and you later undo it, that undo isn't just logged and forgotten. It costs the Team a rung on the ladder. Autonomy is earned from a track record, and it can be un-earned by that same track record.

The reason we treat an undo as the signal, rather than something softer, is that it's the one thing an approval can't fake. When you click approve, all that really tells us is that someone clicked approve. It doesn't tell us the work was good. An undo tells us something stronger: the Team acted, and once that action met the real world, it turned out to be wrong. That's a signal worth reacting to. So when it happens, the Team's track record takes the hit, it can cross the line that the next level up depends on, and it steps back down a rung until it rebuilds trust.

This only applies to work the Team did on its own. If you personally approved something and it later turned out wrong, that doesn't count against the Team, because a human made that call, not the agent. The ladder only reacts when the Team acted without you and got it wrong.

Let me know if that makes sense - happy to dive in deeper!

@eriktaheri Love this question! But my honest answer... less than you'd guess, and I'd argue that's the on-brand answer.

By YAGNI's own rules, launch day is the worst possible thing to delegate. It's first-time work with no track record, it's high blast radius, and it's mostly 1:1 conversations with strangers that I genuinely want to have myself. In our model, a brand-new kind of work starts at the bottom of the ladder: training level, drafts only, human approves everything. That applies to my Teams the same as yours. If I'd handed launch day to an agent Team and called it a win, that would be exactly the unmanaged-agent move we built this product to prevent.

What YAGNI did do today is keep the normal machinery running in the background while I've been heads-down here all day. That's the actual promise of the product: not that an agent runs your launch, but that the routine work doesn't stall while you spend a whole day on something only you can do. Answering you is the part I kept, and the part I wanted!

Really appreciate the question - thanks!

@samirrashed Thank you - I appreciate that. Let me know if you have any questions!

@vikramp7470 That was one of the main driving forces to building this! Thanks for the kind words Vikram. Let me know if you have any questions or if I can provide more context.

@suryansh_tiwari2 Thank you for the kind words! I appreciate it.

@augustoody Great question!

Deciding on the ladder itself was the first challenge! I started naively just building AI automation, but the ladder came out of real user feedback, and I think it's become one of the most valuable parts of the product.

Beyond that, it was deciding what counts as evidence. Our first version only counted clean approvals, and it had an embarrassing flaw: nobody ever graduated. Because that's not how a good manager behaves. You don't approve a draft untouched, you reshape it a little and ship it. So Teams were doing steadily better work, getting edited-then-shipped every time, and the trust score sat at zero. The fix was realizing an edit you shipped is stronger evidence than a blind yes. You clearly looked at it, exercised judgment, and put your name on the result. Once edits counted, the ladder started matching how delegation actually feels.

The second hard part was accepting that some things should never graduate. How much trust a Team has earned and what a given action can ever be trusted with are two separate questions. Wiring money, mass sends, deleting things, a Team changing its own configuration: those stay human-approved forever, no matter how good the track record gets.

On rubber-stamping: my honest answer is that the ladder is the anti-rubber-stamping mechanism. Rubber-stamping happens when your queue fills up with low-stakes asks and your attention gets trained to wave things through. Earned autonomy exists to move the routine stuff out of the queue entirely, so what still reaches you is short and worth reading. And when attention does slip, reality collects the debt: if something you waved through gets undone later, that reversal eats the earned trust and can knock the Team down a level. So inattentive approving doesn't quietly compound, it gets repaid. There's also a weekly digest that shows how often you're editing versus approving, which is a decent mirror for whether you've gone quiet on review.

@dhiraj_patel5 Indeed it does! We count "reversals" or substantial edits as mistakes and can even demote the team down in autonomy level.

@akbar_b Both of these hit exactly where the design effort went, so happy to go deep. Sorry if it's too deep :)

On promotion: the signal is not approval rate alone. Three kinds of outcomes feed the ladder. Clean approvals count for it. Edits you shipped also count for it. Reversals, where a human had to undo the agent's work, count against it. A Team levels up on the running total of those, and three separate checks have to pass at once: the total must clear a bar that scales with the Team's caution setting and with the riskiest action type it has actually touched, the reversal rate has to stay under a cap, and the evidence has to be recent. Even then, clearing the bar only produces a suggestion; a human confirms every level change. The system never promotes itself.

And yes, the busy-approval problem is real. We don't pretend to know how carefully you looked before clicking yes. Two things keep lazy approvals from quietly building trust.

• First, the ladder actually values your edits more than your "yes". An edit you shipped is judgment you clearly exercised, so trust doesn't accumulate from unexamined approvals alone.

• Second, reality is the tiebreaker. If you approved something without looking and it turned out wrong, undoing it counts as a reversal, which eats the earned evidence and can knock the Team down a level. A rubber-stamped yes only becomes lasting trust if nothing ever comes back to bite. And in the meantime, the actions where a careless yes would really hurt are exactly the ones that always stay in front of you, with an undo window or as a draft you have to approve.

On the reviewer: the critic and the author are not the same setup. We put the strongest model on the steps that decide what to do and catch what's wrong (planning and review), and a different one on the writing. But honestly, the model split is the smaller half of the defense. What matters more is structure.

The review fans out to three separate reviewers, each with a different brief: is it correct, does it solve what was asked, and will it hold up. Each one starts from a fresh context and can read and run the work or code but not touch it. That means none of them inherit the author's working context, which is where the rationalizations live. The correctness reviewer is non-negotiable: if it doesn't run, the whole review round fails rather than passing on a partial check. Serious findings send the work back to be fixed, and the loop repeats until they're cleared. And the last reviewer is always a human... that final gate never goes away.

I hope that helps - let me know if you have more questions or if I can provide any more context. Thank you!

@aymnart Happy to add some extra context here...

Guardrails in YAGNI aren't a settings page of toggles. Two mechanics combine on every single action.

First, every action a Team can take carries a risk profile: is it reversible, how wide is the blast radius, does it touch money, etc. That profile sets a permanent ceiling on how autonomously that action can ever run. In practice:

• Internal writes, scheduling, drafting a PR: reversible and contained, so this is the class that can eventually run autonomously. Still logged to the Feed with receipts, never silent.

• A 1:1 customer email: contained but not reversible, so it's capped at supervised. It's surfaced per action with an undo window no matter how much trust the Team has earned.

• Wiring money, blasting the whole list, deleting data: irreversible and high blast, so draft-only forever. A human approves every single one, and no amount of earned trust lifts that.

A Team changing its own configuration (its rhythms, its sources) is pinned at draft-only too. A Team never rewires itself silently.

Second, within those ceilings autonomy is earned, not granted. Every Team starts in training, where it drafts everything. Clean approvals and edits you shipped build evidence, reversals count against it, and riskier action types require more evidence. When the bar is met, YAGNI suggests the level up and a human confirms it. The system never promotes itself.

So the effective permission on any action is the minimum of what the Team has earned and what that action type can ever be trusted with. Proactive never means unattended.

Let me know if I can provide any more context, and thanks for the question!

@galdayan I totally agree about the vague "agent memory" pitches. That was a big driving force for designing this (hopefully) clearer architecture.

To answer your question:

Similarity is required on both sides of the edit: what the agent drafted AND how it was revised. So two people correcting the same kind of work in different directions don't blend into one averaged rule... they form separate patterns. Whichever pattern reaches three similar edits first gets proposed first, but the other can still reach the threshold and get proposed too. In practice, the second reviewer's corrections become a competing rule proposal.

Which means yes, you can end up with two rules in tension. What we refuse to do is resolve that silently. Every rule is plain language in one shared playbook per Team, every proposal surfaces in the Feed, and members of that Team can dismiss or retire either one. YAGNI also remembers which rules were in play for each piece of work. If work done under a rule keeps getting reversed by a human, that rule gets flagged for retirement with evidence attached.

To take a step back though, the Team has one playbook in the same way a human team has one style guide. If two reviewers genuinely disagree about how the work should be done, that's a management conversation the system should surface and make legible, not hide behind the scenes. That's my opinion at least!

Let me know if you have any other questions!

@zcanuslusoiuah I'm so happy to hear that!

The "empty room" challenge is one I put a lot of effort into. YAGNI needs context about your business to do its best work, and as a user it's always a pain to give a system a bunch of context just to get started.

So yes, we are building each Teams draft truly custom to your company as you get started, and of course you can edit and tweak their Goals / Responsibilities / Guardrails / etc as you go.

Let me know if you have any other questions!

@virko_kask glad to hear it resonates with you!

Yes, work that "Needs You" is flagged very clearly in the app.

The YAGNI Teams work through a loop like this for most of their work:

1. Map - gather context about the work item)

2. Plan - YAGNI presents a plan for your review and edits

3. Execute - Complete the work

4. Adversarial Review - Specific adversarial agents probe the work for issues, especially with the context of your previous work and corrections

5. Final Review - your place to review the work before it's sent / pushed / merged

At the Plan and Final Review steps the work has a specific "Needs You" flag that automatically routes it to the top of the list. Additionally, we collate everything that needs you into a simple "Feed" so you can easily and efficiently unblock your YAGNI teams.

I hope that answers your question, but happy to provide more context as well. I appreciate it!

@alex_iliescu The short version is that onboarding teaches it by having you do it, not by explaining it. You start by recruiting the Team and setting what it's responsible for, the same first move you'd make with a hire. Then it starts in training mode, drafting everything for your approval and acting on nothing, so from minute one you're managing: reviewing, editing, approving. You learn the loop by living it rather than reading about it.

The scaffolding is deliberately the curriculum. Seeing a Team draft real work and earn its way toward more responsibility is what makes "manage like humans" click, in a way a tooltip never could.

Thank you for your support!

@marco_cepeda Thank you so much for the kind words! I'm so glad to hear the generated Teams fit your use case well. Let me know if you have any questions!

@ssadtler Great question!

Getting to Supervised is usually fast (within a matter of days). For Autonomous, honestly I recommend at least two weeks in Supervised before promoting. You can do it faster, but a few weeks of works provides a better level of confidence that the agent is on the right track.

On checks once autonomous: autonomy is never a blanket switch. Every action is still clamped by its own risk ceiling, so newer, higher-stakes work stays gated even for a Team that's earned autonomy on its routine work. Anything irreversible, anything touching money, anything going out broadly never auto-runs regardless of status. And even the work that does run on its own is recorded to the Feed and its work item, never silent, stays under a daily volume cap, and is still subject to reversal: if something it did autonomously turns out wrong, undoing it claws back a level. So "autonomous" means trusted on the work it has a track record for, not trusted on everything from here on.

Thanks again for your thoughts! Let me know if I can provide more context.

@axel_florence Congrats on the launch! From a product strategy perspective, which user behavior surprised you most during beta? Were people relying more on AI-generated first drafts, or spending more time refining designs manually? Those insights often reveal where the real product value lies.

@scottwyden Thank you for your thoughtful comment, this is so great to hear!

@scottwyden Your post means the world to us. "Instead of using AI to fake my voice, this tool eliminates the mechanical burden" is exactly it. We built Studio to start with the human, use AI to accelerate, and end with the human, and you living that out is the whole point made real. The part that gets me most is the last line. Clawing time back for family is what leveling the playing field is actually for. Thank you, Scott.

@scottwyden thank you for this lovely review! Appreciate you so much and glad you're finding value in this tool 🫶

@peggy_fitzpatrick This made my whole morning. The brand kit doing the quiet work in the background is my favorite part, you set it up once and every email after just looks like you. Thank you for sharing.

@peggy_fitzpatrick ahhh we're THRILLED to hear Studio is boosting your business's workflow 🫶🫶🫶

@anja_seemuller So well done, Anja! 👏 There's so much thoughtful human touches and craft behind this. Thanks for highlighting some of the important design work that went into this. I'm sure users will feel the huge difference this makes!

@anja_seemuller "The defaults that quietly do the right thing" is the whole product philosophy in one line. Everyone in this thread should take Anja up on the AMA, the thinking and care that went into building this product is truly inspiring. Thank you for all of your hard work.

@crystalmei Thank you so much! We're glad you found it approachable :)

@limin_lam 100%! Thank you for making it happen 🙌

@eiran_trethowan Thank you! This is great to hear ☺️

@veyselsonal Thank you for giving it a try! There's a option to save a block to your favorites. Is this what you are looking for, or something else?

@zcanhasanoiulk Thank you! This is great feedback and something we have in the backlog for a future update. How are you currently going about testing dark mode? Sending a test email to yourself?

@wynter_chatman This is exactly what we hoped Studio would do. 🥹

Not make your emails sound like everyone else's, but make it easier to sound like you. So happy it's helping your "too muchness" shine through because that's the good stuff. 💜

@suryansh_tiwari2 Thank you so much! That was one of our biggest priorities while building Studio.

You upload your brand elements, like your colors, fonts, logos, and imagery, and Studio uses them alongside layouts created by our in-house design team. AI helps accelerate the process and refine the content, but the creative foundation is built by real designers, so every email still feels polished and unmistakably on-brand.

Really appreciate the kind words. Excited for you to try it!

@nicole_sroka This is so great to hear, Nicole!

@omri_ben_shoham1 Awesome! Yes it will pull from your brand! Test it out and let us know how it goes 🙏

@ringo_td5 You only need to set your brand once initially in Studio and it will be consistent across series / across all emails you create afterwards. If you have an existing Flodesk account (our full email marketing platform) it can pull your brand details from it automatically :) Give it a try and let us know how it goes!

@pjsu Thanks! Do you mean inserting a GIF in the email? Or generating images within Studio? Or something else?

@marthabitar So well said! Thank you for the support 🫶

@abby_wynne Hi Abby 👋 Thank you for the kind words!

@hazel_brooks What kind of long emails are your thinking about? There's options for text-heavy emails, where the design leaves a lot of room for longer text content, for a newsletter for instance.

@brody_vincent There's endless outputs depending on what your initial prompt is and how your decide the customize the email. Once your prompt is in, the tool will generate 3 design options for you to choose from. And once you choose one, you can modify it via the agent or manually in the builder (with lots of difference blocks available). So there's plenty of design customization possible!

@erica_rooney This means the world to us. 💛 Thank you for trusting us from the very beginning and for letting us be a small part of your business journey.

We're so excited to keep building Studio, and we can't wait to show you what's next. Thanks for being with us every step of the way. 🫶

@nthglsn 🦊 Foxy picked your launch out of today's batch.

One-click Meet capture and transcription with zero setup is the kind of utility people keep — the friction here was always the bot joining and the config.

That's why we didn't just upvote — FoxPlug takes a launch like this and spins it into a video, looping GIFs, and channel-native posts you can paste anywhere. Free, no signup.

https://www.youtube.com/watch?v=QEI-pISKKPM

The 30-second idea to steal right now: make a Show HN on the one-click / no-bot angle — HN respects tools that remove a step everyone just tolerates.

Do the same for your launch, free at foxplug.com

@nthglsn Congrats on the launch! I'm curious, what has surprised you most during beta? Did users value the bot-free experience more than AI summaries, or was there another feature that ended up driving retention? Those insights are often the most interesting part of product building.

@nthglsn How is this one different from the other such meeting recorders out there?

@burhanmpux Thank you!

@thys_beesman The recording is local to your machine so we can't ask for other participants consent, it's up to you to tell them.

@thys_beesman I was going to say the same thing. It is illegal in many jurisdictions to record without consent (all party consent is required)

@thys_beesman This is the right area to be explicit about IMO. A lightweight participant-facing consent/reminder option could help teams use it in stricter jurisdictions without losing the local/private workflow. Curious if you're thinking about policy controls per workspace?

@pablo_vegas 1h max on the free plan and up to 6h on the paid plans

@aliyeu3327 Yes! also there are some times where you want to record a call for your own personal usage and don't want to make your attendees uncomfortable about it

@negistulay10984 Yes 100% It's coming soon in the next release!

@philip_isik "Rich text is not plain text" — I build AI text editing on macOS and feel that line in my bones. The structured-document diff engine is exactly the piece I'd never have wanted to build from scratch. How does it handle a human editing the same paragraph mid-AI-edit — does the diff reconcile against the live collab state, or snapshot at request time?

@philip_isik Congrats on the launch! Looking ahead, do you see Tiptap evolving beyond an editor toolkit into a broader collaborative content platform, or do you plan to stay focused on being the best infrastructure layer that other products build on? That positioning choice feels really interesting from a product strategy perspective.

@hung_tran_from_notebook_os 
To help AI understand the custom nodes of the document, the AI Toolkit generates a systemPrompt string that explains the different elements of the document and how they are encoded. You can attach this string to the system prompt. The systemPrompt string always has the same value, so you'll benefit from your AI provider's caching and save token costs.

For large documents, the AI Toolkit reads them chunk by chunk so the document does not overflow the context window. The chunk size can be configured by the developer. We're also looking into dedicated search tools, to help AI navigate long documents. All of this should help you keep token costs low.

@smet0b2o Very happy to hear that 😁

@vladimir_iudin There are multiple ways. From a UX/UI perspective, one would be to let AI make edits in suggestion mode, like in our demo here: https://template.tiptap.dev/page-ai-toolkit/

@vladimir_iudin 
That's a very good question. If the AI messes up the document, the user loses trust.

To tackle this, we first built the Smart Diff algorithm, which can accurately compare two documents. See it live here: https://tiptap.dev/docs/ai/ai-toolkit/client/advanced-guides/compare-documents

Then, we built the Tracked Changes extension. It allows you to display changes as suggested edits that users can accept or reject.

Finally, we set up the AI Toolkit so that, every time the AI makes a change to the document, we use the Smart Diff algorithm to find the places where the document changed, and then we use Tracked Changes to display each change as a suggested edit.

See a demo here: https://tiptap.dev/docs/ai/ai-toolkit/agents/tracked-changes

@galdayan In the current version, the AI can edit any node in the document.

One of the items in our roadmap is to allow developers to define allowed/protected nodes, to restrict what content the agent can modify.

We'd like to know more about your requirements. You can contact us at humans@tiptap.dev and if it makes sense, we can add this feature to our product

@anand_thakkar1 The AI Toolkit integrates with Tiptap collaboration and version history. Any conflicting edit made to the AI works the same way as edits made by two users simultaneously to the same document. If you're interested in using the AI Toolkit but and you have certain requirements you'd like it to cover for your application, write to us at humans@tiptap.dev and we'll work to make sure these requirements are met.

@subhh Congrats on the launch! I'm curious, which use case has shown the strongest traction so far: finding hackathon teammates, startup co-founders, open-source contributors, or local coding partners? It's always fascinating to see where real user behavior differs from the original product hypothesis.

@shun_build 

はじめまして。シンガポール在住のロイ・マーティンと申します。

フルスタックエンジニアとして、これまでさまざまな日本企業・日本のお客様との開発プロジェクトに携わってまいりました。日本語で円滑かつ柔軟なコミュニケーションを取りながら、幅広く対応しております。

貴社のプロジェクトに大変魅力を感じており、ぜひ開発メンバーの一員として貢献したいと考え、ご連絡いたしました。

ユーザーに価値を提供できる素晴らしいプロダクトを、ぜひご一緒に創り上げていければ幸いです。

何卒よろしくお願いいたします。

@galdayan Thank you so much for sharing this 😁🙏

Right now: proof is a photo/screenshot judged by AI, no human in the loop, and the bar is deliberately loose. This is beta, so I'd rather err toward false-accepts than take $5 off someone because the model didn't like a badly lit photo. A wrongly-kept stake is annoying; a wrongly-taken one is a refund and a churned user.

So yes — a blurry "done" photo passes today. I'm treating that as acceptable beta debt, not a solved problem.

Where it goes: a stricter review process with real teeth — clearer proof specs per task type, human escalation on low-confidence cases, and ideally verification that doesn't rely on the user producing evidence at all (looking at screenpipe for this — if the task was "write the draft," the machine already knows).

@omri_ben_shoham1 Thanks so much for writing this 🙏
Honest answer: not yet. nudge doesn't automatically re-plan the rest of the week when something slips — it won't reshuffle priorities on its own.

What it does today is closer to conversational: when something gets pushed, you tell nudge in Slack and it slots the task back in around what's already there. So it's not "silently rebuilt your week," but it's also not you dragging blocks around a calendar — you say "this moved," it handles the re-slotting. That's honestly the ceiling of what the tool does right now.

But this is a great point and it's the version I want to build. The trigger shouldn't have to be you remembering to say something — a task going untouched past its slot is already a signal, and nudge should be the one starting that conversation, not waiting for you. Adding this to the roadmap.

@clement_avq hank you so much for this question — you went exactly where I hoped someone would. 🙏

Short honest answer: neither deadline nor $. It's oldest slip first:

• Tasks are ordered by their original date — the one that's been pushed the longest gets today's first free slot.
• Slots are your real availability: working hours minus calendar events and lunch, on a 15-min grid.
• The $ locked never buys priority — the lock is a commitment device, not a bid. And if something doesn't fit today, it isn't squeezed or hidden: it stays overdue, appears in your morning digest, and retries tomorrow.

Deadline weighting is a fair idea and honestly isn't in there yet — the current bet is that the longest-avoided task is the one that needs daylight first. Thanks again for asking the sharp version of this. 🌅

@zlem82302231267 Wow, thank you — I really appreciate you taking the time to share this! 🙏

A scoped share link for a single task (without opening up your whole week) is a great idea, and honestly it fits perfectly with nudge's "never open the app" philosophy. I'll definitely look into including this in the next update.

Feedback like this means a lot to a solo builder. Thank you!😄

@tabitha_robyn Thank you so much🙏😄 — that's exactly the pain I built nudge around, so it means a lot that it landed.

And yes, I'd love to see the voice guide. Send it over whenever.😄

@roopesh_donde thanks for the feedback! Remote for Figma slides is actually a pretty cool idea🤔

@ethan_cheng thanks for your question! Quite a few people already asked about PPT, so I guess it becomes a priority now 🙂
Do you normally use PowerPoint Online or the desktop version?

@omri_ben_shoham1 thanks for support! As for the notes - yes, they stay in sync with all the cop-presenters. You can go back and forth and the notes will reflect whatever the current slide is. Even if the host updated notes after the presentation started (unlikely but can happen) - all the co-presenters get the updated notes right away.

@irham_fatema thanks for your question! The main functionality, which is remote clicker and co-presenting will remain free forever. At the same time I'm introducing a Pro plan with extra features and support.

@galdayan good question! Every co-presenter that joins needs to provide their name so the host can identify them in the host controller. I'm adding a new feature soon that will allow hosts to remove co-presenters they didn't invite.

@tarqiya_forgah thanks for your question! After I add more essential features to Google Slides, I'm planning to expand to other platforms.

@omri_ben_shoham1 for now I'm planning to build more features, specifically for Q&A so presenters on stage can see questions from the audience on their phones inside the clicker. After that will be looking into PowerPoint online and potentially Figma Slides.

@andrei_rebrov1 thanks for the support! Timer has actually been requested a few times so it will be added pretty soon 🙂

@nurcanzalp1zl8 thanks for a valuable feedback. Currently co-presenters can see the current slide preview but I guess the next slide is more valuable 🤔

@neslihanka91107 I was thinking of adding the time but now will definitely do it sooner rather than later😀

@sultankzbs thanks for your support!

@lker1415706 this is very valuable feedback. Thanks heaps🙏

@kuzeyozbas33462 yeah the swipe feature is actually pretty cool - glad that you liked it!

@dndjkwr thanks for the support 🙂

@andrasczeizel Hey man, this is such a great question!! And something we considered while building this feature. To be clear, the AI feedback tool first asks you clarifying questions, such as what kind of video you're making (talking head, YouTube style, explainer, or short form content), and understands which platform you're publishing on and so on and so forth. Before analyzing your video, running it against data, and finally giving you (hopefully) and insightful feedback!!

What I'd love is for you to try it out with your launch and product videos and let us know what you think 💭 💪

@vladimir_iudin Such an interesting thought. To be clear, Eddie's AI feedback feature works independently. It stands as supplemental to the human feedback. I would encourage you to try it out!!! Lmk what you think:)

@alex_iliescu Awesome, thanks.

@leo404 Awesome, thanks. I would say try it out! You don't need anything installed.

@faithada Hey, this is a great point. The way it decides the edit is both using your stated objectives and using its understanding of what makes a good edit, which it has been trained on.

@tahsin_amio Great idea. Totally possible. I'll work on this and DM you soon.

@omri_ben_shoham1 Yes, the AI review does get sharper over time. We have another feature releasing next week, which will accentuate this even more. I would say just try it out and let me know what you think.

@raphael_kamm Awesome, thanks!!

@shamirallibhai  @thisiskp_ Amazing, thanks again for the hunt, @thisiskp_!

@necla170457 Great question. Right now, we don't support projects with multiple languages in the same go, but we will soon.

@gizemezmj Yo, that's a good idea! I'll see what can be done. Thanks.

@kyakl74353 Glad to hear it. We already have a way to generate short-form clips. Please try it out and let me know what you think

@abantakanancyy Duuudddeeee! You won't believe what we have cooking;) DM me on Li/X for early access haha

@thys_beesman To be fair, to some extent, all feedback is subjective. Let's try this again. The AI Feedback feature gets context from you, then analyzes the video, and then provides fine-tuned feedback. When your teammates provide feedback, the AI correlates and summarizes all of that and helps you build an action plan. Try it out. That's the best way to understand!!!! Let me know what you think :)

Thank you @thisiskp_ for hunting this!!! 💐💐💐

@gyorgysh brewed it right away on my mac. Easy to use and looks good - nice little tool! Now I can burn more tokens on @Claude by Anthropic haha.

@gyorgysh Hey Gyorgy! Congrats on shipping Keepresso — saw it's live on Product Hunt today. Love the thumbshell mode concept, super clean idea.

I make short promo edits/reels for indie apps (the kind that do well on X/TikTok). Would you be down for me to put one together for Keepresso? No strings attached, just want to help it get more eyes — happy to send it over for you to use or tweak however you like.

Let me know!

@yunusdemirsoy Thank you for the suggestion! Good news: this already exists.
"Pause on low battery" in Preferences > General lets the Mac sleep once the charge dips below a level you pick, even mid-session. It was built exactly for forgotten sessions, so you don't pull a laptop out of your bag at 0%.

It also pairs well with closed-display mode: lid shut, screen off, and if the battery drops below your threshold it gracefully lets the Mac sleep instead of draining flat.

A caffeine-level slider that tapers off is an interesting angle though. If you mean something beyond the percentage cutoff, tell me more and I'll see how to work it in 🙏

@galdayan Hey Gal. Most managed corporate laptops today run detection well beyond a simple active/away state on Slack or Teams, so relying on this to game presence on a monitored device would likely run into other checks anyway.

The feature is really aimed at everyday cases: keeping Discord or Slack from flipping you to away during a long call or while reading something without touching the mouse, keeping a remote desktop session alive, or stopping apps that log you out after inactivity. Same idea applies to things like screen-share tools or dashboards that assume no input means nobody's watching.

Appreciate you raising it though, good signal that it needs clearer framing.

@bryanlparker Hi Bryan, thanks! Took a look at Caffeine, you'll feel right at home with some extra flexibility and automations on top. Already got some great ideas from the comments that I'm working on now. If you have any suggestions or feedback, always welcome. Thanks a lot, keep shipping 🙌

@andrei_rebrov1 Hey Andrei. Yes, that's exactly what the trigger engine handles. On first launch there's a "Meetings & calls" option you can tap to set it up, and it keeps the Mac awake only while a camera or mic is actually in use, so it covers Zoom, Teams, FaceTime, even a call in a browser tab, in one rule. It reads the system's "device in use" state, so no camera or mic permission is needed and you never get a prompt.

Downloads work the same way as a trigger: point it at a folder and it stays awake while a download is in progress, or use the network throughput rule. You can mix and match all of it under Preferences > Triggers.

Thank you! Let me know how it goes. Any issues, feature requests, or suggestions, I'd be happy to hear it. Cheers.

@omri_ben_shoham1 Hey Omri! Fair question, and for the basics you're right. If timed sessions and closed-display are all you need, caffeinate -s in a launchd script or Amphetamine both do the job. I'm not going to pretend otherwise.

What sets it apart is that it's built on newer macOS foundations, open source, and genuinely flexible: triggers or manual timers deciding when to run and when not to. Closed-display mode works on battery too, so you can unplug, close the lid, and it keeps going, with a setting to allow sleep below a battery percentage you pick. It also lets the screen turn off when the lid closes, where a lot of tools keep the display running, which isn't a healthy way to handle it.

On the agent side: it can detect an app or process running, but not yet that an agent finished and went idle. You actually gave me a great feature idea there, and a clear direction to take the app to make agentic coding smoother. So expect something on this soon 🚀

Beyond that it's the things caffeinate doesn't touch: HiDPI screen sharing on a headless Mac with no dummy plug, the AWDL gaming and streaming lag fix, keeping Teams and Slack status active, a real CLI and Shortcuts control, macOS Widgets. Open source and notarized, so you can check exactly what it does.

If any of that sounds useful, give it a try. Perfectly fine if your existing tools already cover your workflow.

@ilko_kacharov Thanks Ilko! That was the plan, a truly native productivity app that does what you can't really find anywhere else. If you have any suggestions, requests, or feedback, feel free to share. Always happy to hear it.

@mike_castellano Thanks Mike, tried to make it as useful as I could. Looking forward to hearing how it goes, feedback and suggestions always welcome. Cheers 🙌

@fberrez1 Thank you, I'm glad I wasn't the only one missing this kind of featureset.
Any feedback or suggestions after trying it are very welcome 👍

@alex_iliescu Hey Alex. Not planned, no telemetry, no analytics, no cookies, no user data collection at all. Keepresso is a free open source productivity app, so no real need for an email list.

@emre9gjz It is one of our many differentiators. Tons of founders choose Mantle for the simplicity of adoption. The concierge service also includes migration from other providers.

@aslhan345499 we've lived through the pain and we want to solve it for others properly.

@saksham_salvi we built Clerk to help users get the answers they need and see exactly where those answers come from. When Clerk responds, it biases toward including links to the relevant areas of your cap table in Mantle, so you can click through, review the underlying data, and confirm everything directly in the platform.

@andrasczeizelI love the idea of collaboration rules - adding that to our next roadmap discussion. At its core, Clerk is here to keep your cap table compliant. There will always be a role for lawyers on corporate records and governance; we just want them focused on the high‑value work they’re called in for, not dragged into cap table cleanup.

@omri_ben_shoham1 Great question Omri; at the end of the day, no financing round is going to close unless you have sign off from legal counsel on both sides of the table. You can certainly use Mantle Clerk to generate your pro forma, but it will get hand reviewed by actual lawyers. That's not a bad thing, since the lawyers are fundamentally liable for the deal being successful. Thanks for the question.

@omri_ben_shoham1 the "boring failure mode" framing is exactly right, and honestly the more dangerous one. I've been building an AI chief-of-staff for founders running multiple businesses, and the thing that took months to get right wasn't accuracy, it was getting the tool to say "I'm not sure" instead of quietly guessing. We ended up grading every output (Verified, Very Likely, Needs Review, Monitor Only) so nothing with real consequences ever looks as confident as a verified fact unless it actually is one. Sounds like Clerk is leaning on lawyer sign-off for the same reason. Curious if that confidence signal is visible to the founder before it reaches legal, or only surfaces after something's flagged.

@galdayan at Mantle we treat the cap table as a distillation of the actual filings and agreements over time - and that distillation can include mistakes that deserve to be fixed. Whether Clerk pulled something from an uploaded document, a description of what closed, or someone skipped Clerk altogether and typed it in manually, those entries can be amended. The source of truth is what the paperwork says happened, not whatever happened to get recorded in software on a given day.

@galdayan Fair point, you caught something real!

Missing tags (no album/artist/title) are handled cleanly: they land in an "Unknown Album/Artist" bucket, no crashes, nothing disappears. Missing art just falls back to a placeholder icon.

Inconsistent naming is the actual gap: grouping is exact string match, so "The Beatles" vs "Beatles, The" (or a stray typo/space) creates separate entries. No normalization yet.

Thanks, genuinely hadn't thought hard enough about this. "Correct metadata" was carrying more weight than I realized. Adding normalization to the list. thanks for your feedback!

@bryanlparker I was there too man! :) Glad you liked my app. Thanks

@leo404 Hey! thanks for the feedback and for your questions. For the moment Jam-Pod doesn't support playlist import, nor from local or Apple Music, but you can build your own inside the app. It could be an interesting implementation for the future. Even with a messy library but correct metadata, Jam-Pod should work fine, putting them together in order for you :) For the second question, unfortunately it's a no. It's not bit-perfect as it wasn't my priority for the launch, but it is one of that things I want to put hands on soon.

@omri_ben_shoham1 hey! thanks for the comment! you can put all your FLAC files directly into the app via finder. the apple part is separate. you will have 2 different library (local and apple download) so you will know where to find your music. also you can just turn off Apple Music if you don't use :)

@fanny_guillou thanks for your beautiful comment! I am very happy you liked it. the first idea was to put a wheel there (and I have one that works great) but I was not allowed to do it. but in the end also the second choice maybe is better than the first. happy many people like it. thanks!

@etiennegarcia thanks a lot for your feedback! that was the purpose when I decided to create this app. Glad you appreciate it!

@christiana_pedroni Thanks a lot for your feedback!! :)

@meral297601 Thanks for the feedback, really appreciate it! And yeah, already put the sleep timer on the todo list (interesting the fade-out option)!

@fberrez1 Thanks man! I am trying to rebuild my library after years of streaming music. It seems like when you have access to everything you don't know how to use it. I think is important to get back to intentional listening. Glad you also appreciate the joystick!

@sinansimayibwo Thanks a lot! I am glad you liked the joystick navigation. I focused a lot on that and on the feeling of the joystick. Can take a while to get used to it, but then it feels natural. I think I still can improve it anyway. thanks for the feedback!

@gnepalanclx6es That's the reaction I was hoping for — the haptic feedback took a few iterations to get the timing right (was the same for me), so it's great to hear it actually lands. And yeah, no feed, no "for you" page, just your FLACs and a joystick. That's the whole point. Thanks for giving it a real spin!

@aleynafranko Thanks for the feedback, I really appreciate! yeah definitely a sleep timer is missing here and for sure will be in the next update! :)