PH热榜 | 2026-07-18

@ninghu Congratulations on shipping it! Want to know what demand signals are for this? Run it through marklens.ai

@ninghu For teams using agents today, what’s the single biggest pain you still face with web data quality and how would a perfect extractor make your life easier?

@ninghu Congrats on the launch 🚀

I really like the premise. Most conversations around AI focus on better models, but high quality structured data is just as important. Reducing token usage while returning agent ready JSON instead of human friendly markdown feels like a smart optimization for production workflows.

I'm curious, what's the most complex or chaotic website ZooData has successfully turned into clean structured JSON? Was there a site your team thought would be nearly impossible to parse, but ZooData handled surprisingly well?

Wishing you and the team an incredible launch! 🎉🔥

@ilan1017353 Thanks! You've hit the spirit of it — pay for signal, not bloat. Concretely: pricing is per call, and each call returns clean, typed JSON with only the meaningful fields (empty ones are dropped). A product lookup costs the same whether the page behind it is 50KB or 5MB — the savings show up downstream, where your agent's context gets fields instead of boilerplate.

@glsm11117961978 Thanks! One design detail worth sharing: our MCP tools and REST API are generated from the same codebase — every endpoint's schema, description, and validation share a single source, so the MCP tools never drift out of sync with the API. The server side is also fully stateless, so any MCP client stays reliable at any scale. If anything feels rough in your integration, tell us — we'll fix it!

@artstavenka1 This is the question to ask any extraction system — "fast but wrong" is far scarier than "slow." Our defense: templates are never trusted unconditionally; every request is validated. Extraction output must pass core-field and type checks, and the moment a page stops matching expectations (missing/abnormal core fields), that request auto-escalates to full model extraction — the same slow path a brand-new page type takes. In other words, the default failure mode of a layout change is degrading to "slower but correct," not "fast but confidently wrong."

And an honest caveat: if an A/B variant happens to yield a value that's type-valid but semantically wrong, no extraction system can rule that out 100%. We run continuous quality evals against live pages to catch that kind of drift — and if you ever hit a confidently-wrong value in the wild, send it to support@zoodata.ai. We treat those as bugs, not noise.

@viyozc  Thanks! That's the bet we're making — agents are only as good as the data you hand them. Grab the 1,000 free credits and put it to work on your own use case; we'd love to hear what you build. 谢谢支持!

@omri_ben_shoham1 Fair question, straight answer: a captcha wall / block = a failure case, not billed — credits are only consumed when a call successfully returns data, and the status code in the response is the upstream's real one, so a block is never disguised as a success. The anti-bot arms race is our infrastructure's job (rendering, retries, network diversity), but we won't claim 100% — throw your nastiest site at it; if it fails, it costs you nothing.

@elifeakekep6oh Thanks! That's a deliberate choice: structured JSON is the default output, not a paid add-on. The way we see it, structure is the product — charging extra for clean fields would be billing twice for the core value. One call, one price, structure included.

@irmakb5o5  Thanks! Everyone counts the token bill, but the "time" part you mentioned is the bigger one — every team that parses HTML themselves ends up babysitting a pile of selectors and cleanup scripts that shatter on every redesign. Outsourcing the "URL → fields" step saves more than tokens; it retires an entire maintenance pipeline. That's exactly the part we want to carry for you. 🙌

@grrigore  Thanks for flagging — it's not English-only by design; the open-web extraction is language-agnostic. One thing worth knowing: when we encounter a brand-new page type, the first extraction takes extra time (the system first works out the structure for that type of page — after that, similar pages are fast). Please give it another try in a bit; if you still get nothing back, send us the two URLs (here or at support@zoodata.ai) and we'll confirm what's going on — and report back.

@lavana_cricko Haha, that's literally how this started — we got fed up feeding our own agents markdown soup 😅 The loop was always: fetch → clean → write parsers → page changes → everything breaks. The realization: agents never wanted "text that reads like a webpage," they wanted fields they can act on. That's ZooData. Treat your agents to the 1,000 free credits — they deserve better than soup!

@power_valsha Weeks of real usage before a comment — that's the feedback that actually means something. Thank you. The context-window savings compounding into real bill savings is exactly the problem we set out to kill. Would love to hear what you're building with it.

@omri_ben_shoham1  Thanks! The three lanes come from a simple inversion: instead of asking "how much error detail can we expose," we asked "where does your agent's control flow actually branch" — it branches three ways, so the API only needs to be clear about three things. Every extra lane would just be a branch you write and never take. If you ever hit a case where three lanes aren't enough, come back and challenge that claim

@dipankar_sarkar Honest answer: keys can still drop today — what's "fixed" is each page_type's possible field set (docs level), not the wire payload (sparse; absent means gone). But a fixed full set makes your fix a one-liner: hydrate missing keys to null against the known set at the boundary, and everything downstream sees a stable shape — N guards collapse into 1 hydration. Your layering — full keys fix shape, sourced flag carries honesty — is the right decomposition, exactly where the Jernej thread converged as the opt-in direction.

@asminy6i5 Thanks! The economics you're praising are real — but let me make the mechanics precise, so nobody arrives with the wrong expectations 😄

Billing is a flat price per call, not a per-field meter. The "only pay for what you need" you're describing genuinely exists — just in three other places:

- Responses carry only meaningful fields — no boilerplate, no noise — so your agent's context window (i.e. your LLM token bill) ingests only signal. That's where the big savings live;

- Failures aren't billed — blocks, timeouts, errors: zero;

- Price is independent of page weight — a static page and a heavy SPA cost the same, so you never have to model our costs.

In one line: you pay a predictable flat price for the value you take, and the savings happen downstream in tokens. And thanks on MCP — it runs stateless, so any client stays reliable at any scale.

@sabber_ahamed  Good one. Per-request judgment is deliberate — during an A/B window old and new layouts interleave, so each request is handled on the page it actually got; a "lock-in switchover" would feed half the window to the wrong template. As for thrash cost: it points at us, not you — your price is flat per call, and the internal path never reaches your bill. How we protect ourselves (throttling, when things lock in) is an internal tuning problem. The contract is one line: thrash never reaches your results, and never reaches your bill.

@sabber_ahamed  Same price. The pricing axis is what you take away, not what compute we burn. One scrape, one price — whether that was a featherweight static page or a heavyweight SPA needing a full browser session never appears on your bill. Rendering weight is our cost problem, same direction as the thrash cost discussed above: it hits our margin, not your credits.

Why we're firm on this: with weight-tiered pricing, you can't know which tier a URL lands in before you call it — that's decided by the target site's tech stack, which you neither control nor observe. An agent's spend already carries one naturally floating term (LLM tokens); the data layer doesn't need to add another. A flat unit price leaves this part of your spend with exactly one variable: call count.

One honest footnote: heavier pages are slower (render time is real), just not more expensive. Latency floats; price doesn't.

@sabber_ahamed Neither 😄 The real answer: detected on the spot, degraded honestly, re-learned automatically. Every extraction passes core-field validation — the moment a redesign breaks structure, validation fails and the result is never stamped success; unreadable fields are absent (absence ≡ not extracted), never invented. The structure then re-learns the new layout — first pass slower, speed recovers, self-healing with zero action from you. And every drift trigger lands with attribution on our dashboards — "noticing" is our job, not your downstream data's.

@jasnoor_singh_oberoi  You've asked at exactly the right layer — two-part answer:

1.General extraction (any URL): it runs against the fully rendered DOM. Fetching executes in real browsers — JS runs, async widgets render, then extraction happens. Content that's absent from the initial HTML but appears after render is visible to us.

2.E-commerce intelligence endpoints: the three things you listed are literally the product's core fields. Displayed price, inventory quantity, seller/shop ratings — on our realtime product endpoints these are first-class typed fields, part of the contract, not lucky catches from prose. What comes back is the page's real displayed state at collection time. A live example: when a page shows an asterisked promo price ("$1*"), that's exactly the raw state we return — rather than inventing a number. That brand of honesty has come up a few times in this thread.

As for how this relates to the 75%: rendering completeness and token savings are orthogonal — rendering determines what exists to structure; structuring determines how much your context ingests. We render the page fully first, then compress it into fields. Doing it the other way — grabbing initial HTML to "save" — isn't saving tokens, it's losing data. You're right that this is where the e-commerce quality gap lives.

@amir_mehrabi Great question — and it's exactly why formats are composable on our side. A single call can return json and markdown together (add rawHtml if you want full fidelity): json is for acting now, markdown is for "might matter later." The markdown is a page-faithful rendering of the full content — the long tail the schema didn't catch (a footnote, a promo clause, some odd badge) is still in there, not thrown away.

The agent pattern we see looks like this: act on the fields immediately; stash the markdown cheaply outside the context window (it's just text); and the day a decision actually needs the long tail, feed that one page back to the model to read once. That's the full meaning of "structured-first" — not structure-only, but turning the model's prose-interpretation from "re-read on every hop" into "read once, on demand." What we eliminate is repeated interpretation, not information.

And a footnote: requesting an extra format in the same call doesn't change the price — one call, one price. Keeping that "might matter later" escape hatch costs you nothing at the margin.

@omri_ben_shoham1 Finer than a generic fail code — but honestly, not a full forensic report either. The design is neutral classified codes + real status codes:

- Blocked / access denied (captcha walls fall here) → an access-denied class error, with the target's real HTTP status in meta.statusCode — never one we made up;

- Rate limiting on our side → you get an explicit 429 with X-RateLimit headers before any work runs — and nothing ran, so nothing's billed;

- Structure change → that one's actually not an error: the page is still there and readable, so markdown comes back as normal — only the structured json goes absent or degraded. You get an honest less, never a silent wrong. Which loops right back into the field-trust discussion above.

As for why we don't put finer anti-bot attribution (exactly whose wall, which signal) in the response: two reasons. One, those internal signals change shape and name — letting you integrate against them is handing you a landmine. Two, frankly, precise block-detection details published in an API mostly benefit the wrong audience. We watch the full attribution on our internal dashboards — its job is for us to go fix things, not for you to triage.

What your agent actually needs collapses to three lanes: retryable (transient upstream) / don't-retry (access refused) / content-ok-but-structure-degraded. All three are distinguishable from the response.

@galdayan One call = one rendered page-view — we deliberately don't drive scroll/pagination behind a flat price (that's a cost black box, against everything in this thread). For full result sets: infinite scroll → the interactive variant (you pass explicit scroll/click/wait actions, hard-capped cumulative time, bounded cost); classic pagination → your agent loops over page URLs, flat price each, linear spend. Your agent owns the depth decision; we keep each unit deterministic.

@hazy0 Two good questions, straight answers:

1.The schema is fixed per page type — not per request, not per domain. The system auto-detects the page type (product / article / listing / entity …), and each type has a fixed field set — so the same URL returns the same shape to every agent: deterministic, predictable, cacheable. Also a quick calibration on "pay only for the fields you use": pricing is flat per call; the field economics live in the response containing only meaningful fields — no boilerplate, no noise, your context only ingests signal. There's no caller-supplied custom schema today — you're the second person in this thread to ask, and we hear the signal 😄

2.The fully rendered DOM. Fetching runs in real browsers with JS executed — content that isn't in the initial HTML but appears after render is visible to extraction. For content that only appears after interaction (click-to-expand and friends), there's a separate interactive variant in the API for exactly that.

And honestly, "same URL, constant shape" is an asset in an agent loop: the second time your agent hits the same kind of page, the shape is identical to the first — no defensive programming required.

@dipankar_sarkar You've surfaced something we should carve into the docs, so let's state the contract plainly: absence ≡ not extracted. Whether the page truly had nothing or we failed to grab it — those two genuinely can't be distinguished today, so we don't pretend to: we won't hand you an explicit null that implies "we checked, the page really has none" (that's a guarantee we can't back). Absence means "no value obtained here." One meaning, full stop.

Under that contract, the "shape drift" is milder than it looks: the full field set per page_type is fixed — what varies is only which fields carried a value this time, and absence has exactly one meaning. Your defensive code collapses from "guess two meanings per field" into one global rule: not present = not obtained. Write it once, done.

On explicit-null stable schemas — we considered it, and landed here: since null and absence would carry the same information, sending nulls explicitly buys nothing but token cost. And the first-class consumer of this API is an agent: LLMs are natively robust to absence — "no price in the response" already is the complete information. It's strongly-typed glue code that needs every field present — and that's exactly the layer we hope keeps getting thinner in the agent era. So yes: long term, we're on team minimal payload.

That said, "should an agent-native API look like a traditional API" is a genuinely fun debate — if you disagree, keep this thread going, or take it long-form at support@zoodata.ai.

@arokamal_sethy  Nope — no token billing on our side; extraction is flat credits per call. Tokens only happen when your own LLM reads the result — and structured JSON exists precisely to keep that part as small as possible.

@bayramblrn Thanks! The "win" comes down to this: text is something an agent has to read and guess at, fields are something it can act on — and every wrong guess is a hallucination or a retry. Our entire job is deleting the guessing from your workflow: URL in, named and typed fields out. Verify it from your terminal on real pages — and find us here or at support@zoodata.ai if anything's off.

@fatmasavluhstl Thanks! Developer hours belong in your own product, not in "getting data in" — one key, one call, structured fields back; and for agent workflows you can skip integration code entirely via MCP. Any snags while trying it, shout!

@filizutou Thanks! To us these are two halves of the same problem: feeding agents markdown treats them like human readers, and hand-wiring HTTP integrations treats them like human developers. So we made both ends agent-native — typed JSON fields on the data side, MCP tools out of the box on the interface side. Agents shouldn't read webpages, and they shouldn't read API docs either.

@meralahmedi Perfect timing! Curious what your project is — e-commerce data, content aggregation, or general page monitoring? Tell me what kind of pages you're dealing with and I'll point you to the right endpoint and the exact fields it returns, so you skip the trial-and-error. The 1,000 free credits are enough to run your project's real URLs through it — happy to chat right here or at support@zoodata.ai!

@yusufaktulqthz Haha, you're one day late — or right on time 😄 Here's the most direct test: throw the exact URL that tortured you yesterday at us — the 1,000 free credits are more than enough. If the JSON that comes back has the fields you were parsing for, those hours are gone from your life forever. And if a field is missing, tell us — that feedback is worth more than any upvote.

@justin2025 Thanks for the amazing hunt! 🙌

You nailed it — agents don't need prose, they need fields. Any URL in, clean typed JSON out, plus an MCP server out of the box so Claude/Cursor can pull live Amazon & TikTok Shop data as native tools.

Grab the 1,000 free credits and tell us what breaks — I'll be in the comments all day!

@noctis06 clark code it will work in the repo and do the changes just like codex or claude

@stanislav_kirdey To be honest , I am actually waiting for something that can own an entire workflow instead of just helping with one prompt at a time. The cloud computer+ parallel specialists approach is a really interesting direction. Excited to give it a try.

@stanislav_kirdeyThis is one of those launches that immediately makes me think of real use cases . Looking forward to seeing what people build with Clark . Congrats.

@stanislav_kirdey Love seeing products move beyond chat into actually getting work done. The vision here feels practical , and I'm excited to see how Clark evolves. Congratulations on the launch.

@connor_hayes1 thanks! would love your feedback!

@yeliz972799 thanks!

@xueyanzhang good question! Clark is optimized on doing complex workflows on its own computers with its own browser, and be extremely token efficient

what hermes does with opus 4.8 clark can do with gemini 3.1 flash life (20x cheaper!)

@ill_robyn will add! 💜

@loup_wang clark cloud agent is closer to Manus with a bit more flexibility and power

and clark code is replacement for codex / cc

@anlmaz0sy8 yeah!

@ebru1lid great feature request!

@sabber_ahamed there is a flag it will stop wasting tokens if it fails

@sabber_ahamed it diffs against last run so it is continous information, not same thing every day

@talhakhalidmtk it decides on its own

@amir_mehrabi it shows full proof of work in chat

@galdayan full isolated clarks with full browser and filesystem work in parallel and merge into final artifact

@omri_ben_shoham1 it will try to solve it, and if it needs to login somewhere it willl ask you to take over browser and provide credentials

@umar_saleem clark code

www.clarkchat.com/clark-code should be able to navigate them with ease!

@hamza_afzal_butt yes it can!

@giorgi_daraselia thank you! try clark code IDE as well!

@ozandag user will see browser recordings and extact sources links

@vollos clark code could work on main, but optimized for worktrees

would love your feedback on what would work best by default

@gapostolov We moved off a hosted demo tool less because of price and more because the demo went stale every time the product shipped a UI change. Does self-hosting help there at all, or is a rebuild still manual? Also curious who ends up owning demo upkeep in your users' teams, marketing or sales eng?

@gapostolov Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@gapostolov Congrats on the launch 🚀

I completely agree that a great product can lose attention simply because people never experience its value. Interactive demos bridge that gap far better than screenshots or long explainer videos.

I'm curious, after watching users create demos with LiveDemo, what's the biggest mistake founders consistently make when showcasing their product? Is it trying to show every feature instead of focusing on that one "wow" moment?

Wishing you an amazing launch. Looking forward to seeing LiveDemo help more great products tell their story!

@priya_kushwaha1 
Thanks so much, Priya!
Really glad the live engagement tracking stood out.

Good question - the export rendering happens on the server-side by running a browser which auto-plays the demo while recording the screen.
And it is made available as mp4 and GIF formats.

@byalexai Congrats on the launch. For teams that already use tooltips, walkthroughs, or video tours, what’s the recommended workflow for migrating existing demos into LiveDemo without losing SEO, analytics continuity, or user tracking? Any tips for keeping personalization effective at scale?

@noctis06 
Glad to hear the open-source aspect resonates with you!

To answer your questions directly:

• Data Storage: When you use the open-source version, everything from the initial Chrome extension capture to the final generated demo lives completely within your own self-hosted instance and storage, specifically MongoDb database and S3 storage + Mux for Video. There is no round-trip back to our servers, keeping your data entirely private.

• AI Voiceovers: Demos are pre-rendered server-side, on your server, and you will need to provide your own ElevenLabs/OpenAI API keys in your environment variables. This ensures your assets stay completely reproducible and independent.

@ardaeryilmaz 
Hi Arda! Thank you so much, we'd love for you to give it a spin.

• Voiceover: We use ElevenLabs for our voiceovers, ensuring incredibly high-fidelity, premium, and completely natural-sounding audio.

• Embedding: Yes, absolutely! You can embed demos directly onto your website with zero redirects. You can also embed them natively on Twitter/X and Medium, or drop them into emails as an animated GIF.

@talhakhalidmtk
You can absolutely self-host the entire core platform!

For the AI voiceover piece specifically, you need ElevenLabs API key and for the AI enchancing OpenAI API key

https://github.com/exploitx3/livedemo-deploy

@jim3989898 
Hey Jim!

That's a great observation about our launch cycle.

Let's connect on Twitter/X!
Drop me a DM and I'd love to pull back the curtain and share exactly how these Product Hunt launches compound for us

@german_merlo1 
Thank you German!

@alieksia 
Thank you! Great question.

The core embed script itself loads asynchronously, so it won’t block your main page layout or slow down your initial load time.

Once the main page is ready, the interactive steps and assets stream in seamlessly in the background.
Because it captures high-fidelity visuals, the asset payload can currently sit at a few megabytes, but since it's asynchronously loaded, your core site metrics stay safe.

That said, asset optimization and aggressive file-size reduction are actively on our immediate roadmap to make it even leaner!

@maria_wall_ball 
Thank you so much!
Would love to hear what you think once you try it out!

@omri_ben_shoham1 
Docker-compose for the web editor and for the backend, but you would also need to run the chrome extension to be able to record livedemos.

You can check it out
https://github.com/exploitx3/livedemo-deploy

@muizidn 

Yes,
You can see examples of those videos on our Youtube channel
https://www.youtube.com/@LiveDemoOfficial

@ridhwikvinod 
On the cloud subscription the advanced engagement analytics and lead capture are behind a paid plan.
But for self-hosting the features are already available on github

https://github.com/exploitx3/livedemo-deploy

@adana 

Great question!
You can capture and build a core interactive flow in literally under 5 minutes.
If you want to deeply polish it - adding custom callouts, personalized steps, or matching it perfectly to a specific sales narrative coult take about 15 to 45 minutes.
It’s all about how customized you want the story to be!

@sabber_ahamed 
Thank you for the great question.

No, we don't have per-link server-rendered exports just yet, the MP4/GIF export currently uses the default template values.
Personalization is handled dynamically, so it shines live in the interactive embed.

That said, since the foundation is already built on top of our headless browser rendering architecture, generating custom video/GIF variations per shared link is highly trivial for us to implement.
We can absolutely add this as an improvement very soon!

@anukarop 90 seconds is the capture, but the part that eats my team's time is editing tooltips and scrubbing customer data out of screenshots. How much of that is automated? Asking because the last tool we tried was fast to record and then two hours of cleanup per demo.

@anukarop Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@anukarop What was the single hardest UX trade-off you faced while designing Mirage’s capture flow, and how did you decide which side to favor?

@artstavenka1 Thanks! Good question, and honest answer: hotspots are pinned to coordinates on the screenshot, so if the new UI keeps roughly the same layout, the choreography holds fine. If things moved around, the hotspot and cursor can land a little off, and you'd nudge them back into place on that step. It's a drag-and-drop fix per screen, not a rebuild, so a normal UI refresh is usually a couple minutes of re-tuning to make it feel directed again. Bigger redesigns cost more, but you're only touching the steps that actually changed.

@galdayan Yeah, that's exactly the part I cared about most. View counts just tell you people showed up, not where they quietly gave up. So once you see a hotspot where folks are bailing, you can just fix that one step; reword the tooltip, move the hotspot, reorder it or just swap the screenshot and republish. You just patch the spot that's leaking and move on.

@hazy0 Yep, it's a static snapshot captured at recording time, so your demo stays stable even if your app or API changes later. And yes, you can start from any authenticated state or specific screen, including after entering an email, without forcing viewers through the signup flow.

@zekio0r2 Thanks! Glad it was smooth, that's exactly the experience we were aiming for.

@sabber_ahamed Not yet, but you can do that by creating two separate demos, one before the changes (duplicate one) and one after, then compare their analytics independently.

@anand_thakkar1 Mirage captures the rendered DOM as you navigate authenticated flows, creating static snapshots instead of replaying live requests. That means nothing connects to your backend during playback, so no live data or tokens are ever exposed. You give up real request replay, but in return you get isolated, reliable demos that continue working even as your API evolves!

@abhineetarora Second approach, Mirage takes a snapshot of each screen from your real app, then puts clickable hotspots on top. So it's more of a frozen replay than the live app running; which means no auth or data headaches, it loads instantly, and it keeps working even if your backend changes later. Fidelity stays high since it's your actual UI, not a mockup. Best of luck with your launch, you've got this!

@rakhi_jha2 Thanks, that means a lot! That's exactly the gap we wanted to close. Would love to hear how it goes on your landing page.

@alieksia Thanks! And I agree, drop-off tells you much more than raw views. Mirage handles long flows just fine, there's no capture limit, but the analytics usually show that shorter demos perform better since that's where people stay engaged. I'd capture the full flow first, then trim it down to the key screens that help users understand the value as quickly as possible. Perfect for a launch.

@johan_nystrom Thanks! Really appreciate the suggestion. We love the "must see" vs "optional" hotspot idea and will be adding it in one of our next product updates! 🙌

@omri_ben_shoham1 Honestly, 90s is the clean linear case. Once you've got branches, plan tiers, or gated screens, yeah it takes a bit longer since you're grabbing more than one path. But the capture still does the boring heavy lifting for you, so what's left is just light stuff, fixing copy, reordering, swapping a screenshot. Even on a messy branchy SaaS that's a few minutes of tidying, not building it by hand. We do the bulk, you just tweak the last bit.

@chetan00118 Thank you, and yeah, the dying Loom is basically a founder rite of passage.

Honest answer: a Mirage demo is a captured snapshot, so it won't auto-sync when your live UI changes, but you don't have to redo the whole flow either. If you change button copy or tweak a screen, you can re-capture or swap just that one step, update the tooltip, and republish while the rest of the flow stays intact. So it's not live-mirroring magic, but small UI changes are a quick edit instead of a full re-record, and the per-step drop-off data usually tells you which steps are even worth refreshing.

@vollos Thank you, and that empty demo slot is exactly the itch I was scratching!

So yes, a published demo replays the actual captured frames, but those frames aren't locked. Each step is editable before you go live, so you can swap in a screenshot with placeholder or dummy data, blur or replace anything sensitive, and adjust the tooltip copy to match. Basically you capture the real running app to get the structure and flow, then clean up whatever you don't want public before you hit publish and embed. Nothing goes live that you haven't signed off on.

@satchmo_saunders Thanks, that means a lot! Keeping attention long enough to show the good part is exactly the problem I built this for. I've been answering the other questions in the thread, so take a peek. And whenever you're ready, the first demo's free forever, so no risk in trying it on your SaaS. Would love to hear how it goes.

@harshsurela No interruption at all, really appreciate you recording a full journey and putting it through its paces. Thanks for flagging the disappearing capture too. You caught us mid-upgrade on the editor panel, so that was almost certainly the cause, not anything you did. I'm on it. Really glad the rest felt flexible and easy, thanks for giving it a real shot :)

@madalina_barbu Thanks! The first demo's free forever, no card needed, so give it a spin and tell me what you think. Curious what you'd build with it.

@yalnspirde8n0y This made my day 😊 That "all 40 popped open instantly" is the whole bet — they're just plain files rendered locally, nothing to fetch or sync, so there's nothing to wait on.

But the part I love most is "while i was still reading." The agent's fix lands as a precise edit, so your scroll and cursor don't jump — the broken link just quietly heals under your eyes. That's the shared-whiteboard feeling in one moment.

Thanks for actually throwing a real folder at it — would love to hear what else it runs into~

@agent  @xueyanzhang Congratulations on shipping it! Want to know what demand signals are for this? Run it through @MarkLens

@agent Please feel free to try our agent guidebook — an interactive demo where OpenMarkdown and your agent walk you through it together, including the live co-edit. Paste the prompt into your agent to start (just enable the openmd CLI in Settings first), and let us know if anything doesn't go smoothly~

@agent @xueyanzhang NPU + compiler background explains the "no AI agents built in" choice - you're treating the agent as an external client instead of baking a model in. makes sense given where you come from.

@avantigrowthlab Aha — you've described exactly what we're building for right now. 😄

Real and in testing today: the line the agent's working on lights up live in a dedicated agent color, when done a non-disturbing banner shows, and click to jump the agent's section with highlights. The visuals are render-only; your .md stays plain GFM, no metadata baked in.

A persistent "who wrote this" mark stays off the table (it'd have to live in your file or a shadow copy — we won't). So we chase the in-the-moment version, and making it natural to peel just the agent's edit back off is next on the bench. New version's coming very soon, stay tuned 😊~

@jbrio :) That's the whole bet — we're the whiteboard, not the brain, so bring whatever agent you trust. And the UI's meant to disappear so you two just work — glad it landed. Thanks James~

@ravzaerbeyler The "no setup" part is the whole idea — writing to the file is the integration, nothing in between. Same reason it loads snappy: just plain files. Thanks for the real spin~

@eason_zhou You found the real edge — inside the machine it's clean, and the second the doc leaves for someone without OpenMarkdown, you then become the courier.

Start from a principle: the file on disk stays plain .md, no extra metadata. That was a founding line for us — so "review" doesn't get to live in the file as comment threads or suggestion-mode cruft.

Currently we can use agent as the glue. Agent is used to get the reviewer's note from Slack, and it writes the diff back as a section-scoped edit — same concurrency-safe path as everything else. Nothing uploads, the file never leaves your machine; the reviewer's words just land as a clean edit. You stop being the courier — the agent is.

The harder frontier is when the file itself lives on a shared drive and two people touch it at once. Guarding that concurrency — git/patch-style, staying file-native rather than bolting on a server — is something we're actively chewing on. Not solved, genuinely open.

Curious about your situation: When a correction comes home, is it usually a full edited .md copy, or conversational ("para 3 reads too harsh")? 😊

@dipankar_sarkar Great question!

It diffs, it doesn't reload. The watcher takes the incoming file, computes the minimal diff against your live buffer, and applies just the changed ranges as one precise edit — so a whole-file rewrite that only really touched one section collapses back down to that section. Your cursor, scroll, and undo history ride along on everything that didn't change.

Honest caveat: it's diff-granularity, not literally "sections" — if the edit lands right where your caret sits, that spot does move. But you never eat a full-buffer reload mid-sentence.~

@sabber_ahamed Appreciate that — "nothing leaves the device" is exactly the line, good to hear it's the same bar you hold on-device.

Your agent through the MCP server — the wait_for_change tool blocks until the file actually changes and gets pushed a wake-up.

For your "mid-edit" case specifically: your keystrokes reach disk via autosave, and the wake is tail-edge debounced — it fires once you pause, not on every character. The agent wakes to a settled file, not a half-typed line.

Easiest way to feel it is the interactive guidebook — paste this to your agent and it sets everything up:

Read openmarkdown.dev/install to install OpenMarkdown and open my first note

(just enable the openmd CLI in Settings first). Let me know how it feels~

@sabber_ahamed Yes — agent-to-agent runs on the exact same hash-CAS. The check is on the section's content, not on who's writing, so a second agent (Claude Code in one terminal, an MCP client in another) is treated no differently from a human.

Concretely:

- Different sections → both writes land, no conflict.

- Same section → writes go through the one running app one at a time, so the second one's baseHash is now stale; its replace is rejected and it re-reads. Two agents can't both read a stale hash and silently clobber — the loser gets a CONFLICT and retries, same as human + agent.

That's a guarantee for writes going through "write_section" (they carry the hash). If an agent bypasses the tools and just rewrites the file with plain Write/Edit, it's outside the check — two agents both doing raw file writes fall back to whoever-hits-disk-last.

We are still exploring to push conflict below the section, so two agents editing different sub-parts of the same section don't trip a conflict at all. Today the unit is the section. Please stay tuned~

@dipankar_sarkar Sharpest version of the question — thank you.

Short answer: both, and which one kicks in depends on whether the agent goes through our MCP tools or just writes the file itself.

- Through our MCP (write_section): the agent is constrained to an anchored range — it patches a section by heading, never the whole document (there's no full-document replace).

- Writing the file directly (the case you hit — most agents rewrite the whole thing with their bash tool): we diff the new file against your live buffer and apply only the minimal change, as a remote edit, so your cursor maps through it instead of resetting.

Honest limit: if the rewrite also reflows the whole file, the "minimal" diff stops being minimal — and keeping the agent's edit out of your undo stack is still on my list (still looking for the best design for the best user experience).

You've named the real open gap. Would love your take on anchoring that survives a reflow~

@berkantozg31053 So glad the local-first + MCP co-edit clicked for you 😊

This might already cover it: OpenMarkdown doesn't do a split source / preview pane — it renders live, inline, in the same pane as you (or your agent) type. So formatting drift shows up the moment it's written, with no second pane to keep scroll-synced. One button also cycles to reading mode (the clean rendered page) and source mode.

Personally, live preview has been the best experience for me — each line renders in place as I type. And when I do need the raw markup, source mode renders it with syntax colors (easier on my eyes) instead of a second pane. I kept it single to stay light.

Genuinely curious what a dual pane would give you over live preview — if it's a real gap, I'd love to understand the workflow before deciding.

(I attached two screenshot of the app under "live preview" and "source" mode for reference~

@rabia584457  Really glad the local-first part clicks! And you've named the real tension in co-edit: trust.

Today it's simple: the file stays a plain .md on disk, and Cmd+Z reverts an agent edit like any other.

An in-editor diff is the thing I keep going back and forth on. I've deliberately kept agent edits as plain edits — fast, no approval step — instead of a review tray you have to clear. But your point is exactly the counterweight: without seeing the change, trust is harder.

Honestly, I don't think one approach just wins outright. We're weighing whether edit-in-place and an in-editor diff can coexist — the best of both, or at least leaving the choice to you. We've already looked into the Agent Client Protocol (ACP) (https://github.com/agentclientprotocol/agent-client-protocol) as one path to that in-editor diff.

So which would you actually want: a persistent diff view, or just a clear "here's what changed, undo if you don't like it"? Would love your honest take~

@chetan00118 Great question!
OpenMarkdown's MCP supports section-level writing. There are two situations then.

1. When the agent writes to a different section than the one you're in, its edit lands as a scoped transaction in your live buffer. No reload, no lock.

2. When you're both in the same section, it's optimistic concurrency: every agent write carries a hash of what it read, and if you've touched that section since, the write is rejected (not merged, not overwritten) — your edits are untouched and the agent re-reads and retries. So on a real collision the agent yields 😊

A compare-and-swap per section is lighter, and it keeps the plain .md as the source of truth.
We are still looking for the best way to handle the concurrency for the best user experience and best performance. Let me know if you have any suggestions or other questions~

(ps: a new section for step-by-step interactive agent demo on the landing page should be sync'ed within the next 30 mins; please feel free to give it a try~)

@mingtian_zhang Thank you, that means a lot 😊

On the same-section case: agent writes are section-scoped and carry a hash of what the agent read. Before applying, `openmd` check you haven't changed that section under it — if you have, the write is rejected (not merged, not overwritten) and the agent re-reads and retries, so your edits are never clobbered. Different sections just interleave cleanly.

There's a step-by-step interactive agent demo on the landing page, and you can install by pasting a prompt into your agent: https://openmarkdown.dev Would love to hear how it feels~

@austinbuhl Thanks 😊 Since every file is just plain .md on your disk, it already works with whatever you use — git, Time Machine, your sync folder. Built-in version history inside the app isn't there yet; git has covered it for me so far. Curious what you'd want most: full in-app history, or something lighter like "undo the agent's last edit"? Would love your take~

@inferhaven Thanks for your question 😊 You can absolutely point an agent at a .md in VS Code.

First, OpenMarkdown is a fast markdown surface, not an IDE.

It renders, opens instantly or a quick peek-and-fix, and stays out of the way.

The co-edit path is built for the shared-file case, section-scoped, with your cursor preserved and per-section conflict checks.

It's not a strict replacement. I still live in VS code for code editing. However I do see trend that coding agent is getting better than ever; I use less VS code recently.

OpenMarkdown is for when you want the quick peek into markdown view/edit.

Easiest way to feel the difference: the interactive agent demo on the landing page, install by pasting a prompt into your agent~

@hi_i_am_mimo You're stress-testing exactly the right thing 😊

On reconciliation: it's not a file-watch reload with last-write-wins. Agent writes are section-scoped and land as a transaction in your live buffer. If you're both in the same section, it's optimistic concurrency — every agent write carries a hash of what it read, and if you've touched that section since, the write is rejected (not merged, not overwritten). Your in-flight edits are never clobbered; the agent re-reads and retries. The plain .md stays the source of truth.

On speed: peek-open stays instant for everyday files — dropping the cache is about not hogging RAM (personally, I'd be frustrated to see a "simple editor" eat a huge amount of it). In my own daily use I haven't hit response-time issues with large .md files.

Would love your stress-test notes~

@vitohacker Totally fair — it's a crowded space, and honestly I'm a heavy Obsidian user myself (it's my knowledge base; VS Code is my IDE; Notes (MacOS app) was my scratchpad). OpenMarkdown isn't trying to replace any of them — it came from a few specific frictions those tools left me with:

1. Opening a single file. Obsidian is vault-based — to glance at one design.md or double-check a spec, I have to open a vault. VS Code cold-start is slow. OpenMarkdown opens any .md instantly — no vault, no project.

2. Composing prompts. It's my $EDITOR, so I can write long, structured prompts for my agent without a stray newline firing off a half-written message.

3. Fleeting notes in plain text. Quick thoughts used to land in Notes, but that's WYSIWYG — fiddly to format, and not portable. Here they're just .md: openable in any app, yours forever.

4. The actual new thing — co-edit. Over MCP, the agent you already use can edit the same file alongside you, section-scoped, so you don't clobber each other. That's the part no general markdown editor does.

So it's deliberately narrow — a fast, local-first surface for the human + agent shared-file loop, not another PKM trying to out-Obsidian Obsidian. If you want to feel the difference, the Bring-your-agent guide is the fastest way in: https://openmarkdown.dev — appreciate the honest nudge

@dipankar_sarkar This is a good one. It's atomic today — one undo entry. The rewrite comes in as a single minimal diff applied as one transaction, so ⌘Z reverts all three sections, not just one. Per-section (really targeted) undo is on my list, should be shipped in the next update. What works now: instead of ⌘Z, tell the agent "section 3 is wrong, redo just that one" — it rewrites that section (scoped + hash-checked), the two good edits stay put. Great pressure-test~

@amir_mehrabi Thank you! Keeping authorship distinguishable across several rounds is a great question — and since it's local-first, the .md file is the ground truth, so whatever we do has to live in the file.

Rather than one universal "color the agent's text" layer, I lean toward letting the scenario decide:

- Pure formatting (say, CSV → table): I only care that it's correct — edits happen in place, no provenance needed. (Whether in-place edits should also offer an in-editor review/marker came up in another thread — at least the user should get the choice.)

- Writing a report, where the agent pulls a section in from a repo: a lightweight in-text record fits — e.g. "- [x] @agent · completed 2026-07-18". A timestamp right there in the file is welcome/acceptable.

- A shared task board: you can carve out a dedicated agent-response area in the doc itself, so provenance becomes structural (like the screenshot).

Curious — what scenarios do you reach for most? Would love to figure out together how to make it better~

@anand_thakkar1 Thank you for the insightful question~

Not last-writer-wins — that's the line I most wanted to avoid. On a stale write (section-scoped) the agent's edit is rejected (the section's hash no longer matches what it read) and it re-reads; your in-flight text is never overwritten. So even in your edge case — a big rewrite while you're mid-sentence in that region — the agent yields, not you.

On finer granularity, we are still exploring the right approach. The applied edit is minimal-diffed, so it's small when the real change is small — but the unit of conflict is still the section, not a sub-range. Block-level scoping is likely the right next step for finer control — curious how you'd approach it. Would love your take~

@omri_ben_shoham1 Thank you for your interest 😄 (and no — neither of you silently overwrites the other; a collision just makes the agent re-read and retry.)

Two honest UI caveats for now: no live cursor showing where the agent is (no Google-Docs presence marker), and no red/green diff yet — you see the result appear live, in place, not a before/after.

A diff view is the piece a few folks here have asked for, and your question splits it neatly into two modes I'm weighing:

- live diff — the agent writes, then leave a notification on the banner. click to jump to the newly added section (possibly highlighted in a box); and

- review diff — it commits, then you see a before/after to accept or reject (curosr like).

They could co-exist, if they doesn't affect the response speed too much. Which one do you find more useful?

@galdayan Great question 😊 The editor buffer is the file.

[case 1] when the agent writes to a different section than the one you're in, its edit lands as a scoped transaction in your live buffer: your cursor and unsaved text don't move, no reload.

[case 2] if you both land in the same section at once, the agent's write carries a hash of what it read — if you've changed the context before the agent, that write is rejected and the agent re-reads. So you're never fighting over the same save, and your edit wins.

It's live to try now — step-by-step interactive agent demo on the landing page (install by pasting a prompt into your agent). Let me know how it feels~

@manuarora this is great! Ive used them all and the generic crap it spits out never does the job. This will really fix that issue. Cheers

@manuarora looks awesome! Congrats on the launch!

@manuarora Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@xpaczka Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@shaeofshadows Thanks for the feedback! It goes straight into the vocabulary, but if you don't feel super comfortable with hiragana/katakana, romaji (romanized version of Japanese language) is also include on each flashcard :)

@dfect Very helpful insight, thank you. What was the main pain point for you? Is there something that would make your start easier?

@omri_ben_shoham1 This is a nice idea, that I will definitely give some exploration time. Thanks!

@leo404 
1. If you miss your learning day, the system does not adjust the schedule
2. Currently it's not possible. The idea that I've been exploring recently is to allow you to skip word - marking the word as "burned" so it does not appear in the review queue anymore. I think this could give some boost to the non-entry level learners

@vanmurten_eth Thank for the feedback, I really appreciate it! I hope you will enjoy it :)

@ilko_kacharov I'm really glad you are enjoying the convention, I really appreciate it!

@mystoryland Currently this is more of a motivation layer, a wrapper to make learning words feel like a journey, but this idea is also something I've been thinking about, so this definitely may come as a feature :)

@varun1jan Agreed! I feel like learning language this way feels more like a fun activity, rather than an obligation

@omri_ben_shoham1 Currently, it's a geography theme wrapper, but it's a nice idea to expand more on the prefecture target language. Thank you!

@oktaykurung9z0 I'm really glad you enjoy it!

@mifiko Thank you for the feedback! I will definitely try to include some for in-app insights :)

@galdayan Yes, the progress will be synced between both platforms, so you can use your account for both environments

@busmark_w_nika I think it's because most of the people like Japanese culture hence they want to learn their language!

@busmark_w_nika I've been learning Japanese for 2+ years now and as I was growing my grammar knowledge more, I've realized that I still lack the real vocabulary needed for day-to-day conversations. Other apps that I've used didn't give me enough to be able to really grow my vocabulary skillset - so I've decided I can build one as I believe that having enough vocabulary knowledge is the most essential aspect in any language learning path :)

@metehan_sipahi Congratulations on shipping it! Want to know what demand signals are for this? Run it through marklens.ai, only takes a minute! Happy Launching!

@metehan_sipahi I really love the approach of controlled randomness here. So many experimental synths just spit out chaotic noise, so making sure the generated sounds stay within musical boundaries and are actually playable is a massive plus. The dynamic radar visualizer is a super nice touch too. To answer your question I definitely lean towards faster results to keep the creative momentum going. Best of luck today!

@paulmurnane The failure mode I keep hitting isn't finding the doc, it's that three docs disagree and nobody knows which is current. Does it do anything with conflicting or outdated sources, or does it treat everything in the index as equally true? That's the bit that decided it for us last time we evaluated something in this space.

@paulmurnane Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@michael_yagudaev You've solved the problem I didn't know I had—watching four different coding agents work in parallel without losing everything when my machine restarts.

Your gallery could use more flair alongside the video. I made you an animated clip from your own launch images — free, fully unbranded, yours: https://foxplug.com/g/8acc16e7ea414f449535. Add it while the launch is still editable.

https://www.youtube.com/watch?v=NY6uIkBXExc

Made it with FoxPlug — the go-to-market system behind it. It connects to the real substance of your company (your repos, your funding and backers, your database, your live product) and turns what's actually happening into what customers and investors need to see: launch posts, threads, long-form LinkedIn, blog pieces, GIFs and video, a white-label changelog you control per plan, and press pitches. Two ways to run it — GTM and Go To Sleep (we run it for you) or GTM and Go Full Control (you drive, $29/mo): https://foxplug.com/gtm?utm_source=producthunt&utm_medium=comment

@michael_yagudaev Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@michael_yagudaev congrats on the launch, this looks awesome guys!

@teddyni Thank you so much Teddy :). MP is a legendary product and I love seeing Steve using MP inside of AgentGrid for his design workflow :)

@teddyni Thank you! And yes!! We need to close the gap between intent and shipped code.

I'd love to see how you apply AgentGrid.

@switmer777 You are a legend, Steve :). We might as well list you as a maker here with all the amazing feedback you have been giving us. Thank you so much! I cannot get back to building. There is soo much more to do 🚀

@switmer777 an OG, with utmost respect, having you as an early adopter has been amazing!!

@tokifyi epic ❤️. Thanks so much toki. What are you building this weekend? 😀

@tokifyi It's awesome to hear this!! I am excited to see what you ship!

@omri_ben_shoham1 AgentGrid exposes tools to agents so they can use such tools to query and feed their context. Think of how agents could use bash to hunt down information. On AgentGrid, they can find the info, connect to it, and truly collaborate

@omri_ben_shoham1 exactly :). Creative process is messy and you need space to think. I literally don't know how to build without AG anymore. Broke it a few times early on and it suck having to go back to single terminal session 🤮

@naimej1tx I am so happy that you found AgentGrid useful!

@naimej1tx Thanks so much Naime ❤️. Can't wait to see what you create :). Any weekend project ideas? :)

@souren LFG 🚀🚀🚀

@anish27 Thank you Anish! It's so awesome to see you here!!

@anish27 Thank you so much Anish ❤️

@galdayan Great question, I've seen it resume a session before. I think it depends on the harness and how it is implemented. So to give a better answer, I'll have to test it :). But in either case we should resume it.

One other user asked that we prevent the computer from shutting down if there is a worker that is working. He had macOS attempt to do a system restart on an overnight task, shut down AG and fail on another process (unrelated). So it failed both to apply patches and complete assigned agentic work.

So ideally, the computer would wait until it is free with an advisory warning, to let the harness know like "hey, we need to restart, wrap up and we will continue when we are back". Then on startup again just resume it.

That's what I'll try to add next week, hold me to it :)

@galdayan @michael_yagudaev This is a good point, I think partly we're moving towards more persistence beyond the tab/window restart. We've shipped daemon support (kinda like Docker) and we're experimenting with continued persistence in that fashion

@alexdanilowicz Magic Patterns more like EPIC Patterns :). If you ever sell to Epic games 🤙... Talk to a few design teams too about MP and the iteration speed of the agent. Maybe we can add an MP harness in there in the future, that would be really cool

@alexdanilowicz This is so awesome to hear! I can't wait to see how you and the MP team use AgentGrid!

@manuarora thank you Manu! I would love your feedback if you have any and I would love to see what you end up building with AgentGrid!

@manuarora Thank you so much Manu ❤️. Can't wait to see what a legendary maker like you can do with this.

@Souren  @omri_ben_shoham1 Thanks Omri :). It depends what you mean "what agent found what". You can visually see what agents have access to with connections and can search through them.

We are working on better organization and sorting now too to make it easier.

You can ask a single master agent for a status update. It will connect to all other masters and look at where things are. We've been thinking about even an ai-boss agent. Souren has a really cool protoype he can show you :)

@omri_ben_shoham1 @michael_yagudaev Adding to what Michael said. We're thinking rather than treating AI agents as "employees" that can "do stuff for you" instead think of them as AI supervisors that bring important things and decisions to your attention. A cross-canvas context awareness is a helpful step in that direction

@kesleralya91117 exactly what sold me too, the fear of restarting my machine with every apple reset. I also love just having the mental reset sometimes and need to clear the deck like that.

Any ideas on how we can make the persistence more front and center on the landing page? That is a big thing we've been hearing from a LOT of early users.

One user even asked to prevent the Mac from restarting on system updates if there are working sessions. Like overnight tasks you leave (will look into this more after launch)

@kesleralya91117 this. Yes. The anxiety I had anytime my IDE would crash. 😵

@kesleralya91117 builders building for builders. 🚀

I would love to hear more about your experience!

@iuraf1721 Thank you :). What are you making now?

@nilans thanks a lot Nilan ❤️. I miss seeing your product creations; maybe you can cook something up with this :)

@nilans thank you! I would love to see what you build with AgentGrid!

@shawn_esquivel great questions :). About 300+ for me, we are improving performance now as TUI is terrible rendering pref. Once we do that next week it should be 1000+. MacOS has a 511 file description limit you can increase too with a quick bash command.

Typically, I let the agent decide how many parallel tasks to do, claude & codex are really good at that.

The challenge is making the review process breezy for you, I typically have agents review each other and leave screenshots. Triage the PRs with low LOC count for quick win merges for human review and get those shipped to real customers.

I'll be creating more resources as we go and will talk to you guys at Composio on itegration ideas :)

@shawn_esquivel I am so excited to see you try each one! And thank you for the support!

My workflow has been consistent in having multiple orchestrators working on different problems in different work trees. Each of these orchestrators has multiple adversarial reviewers, where each reviewer is a different model and harness. Sometimes I do Codex grok and Claude workers for a feature that a cloud builder shipped, all orchestrated under the same cloud orchestrator.

The primary purpose of AgentGrid is to remove the human from the loop. Obviously we're all the bottlenecks so this is definitely a solution or at least a step towards that.

@mittalpatel Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@abdulsametvgoc 

Thanks so much, Abdulsamet! 🙌 Really glad it worked that smoothly for you, that's exactly the experience we were going for.

@shivani_patel18 

Good question! We have a plan that scales with usage, so a smaller team attending a few events a year isn't paying for a heavy monthly commitment.

Happy to walk you through specifics if you check out the pricing page, and open to feedback if something doesn't fit your case.

@furkanbeki61828 

Thank you, that really means a lot! 🙌 The handoff is designed to feel seamless on the WhatsApp side, the AI keeps the same thread going, so the human rep just steps into the conversation with full context already there. No "please hold" or starting over.

Would love for you to try it and see how the handoff actually feels on your end, that's exactly the kind of feedback we're looking for today!

@yorgan47831 

That's amazing to hear, Cem, thank you! 🙌 Really glad the enrichment felt fast and the drafts didn't come off generic, getting that personalization right (and not just a name swapped into a template) was something we spent a lot of time on.

Curious, did you end up sending any of those drafts as-is, or did you tweak them before sending?

@vivek_dwivedi13 Your reality simulator actually shows me the specific ways my startup could fail before I waste six months finding out the hard way.

Your gallery could use more flair alongside the video. I made you an animated clip from your own launch images — free, fully unbranded, yours: https://foxplug.com/g/6b514c9518a646cd8c66. Add it while the launch is still editable.

https://www.youtube.com/watch?v=NY6uIkBXExc

Made it with FoxPlug — the go-to-market system behind it. It connects to the real substance of your company (your repos, your funding and backers, your database, your live product) and turns what's actually happening into what customers and investors need to see: launch posts, threads, long-form LinkedIn, blog pieces, GIFs and video, a white-label changelog you control per plan, and press pitches. Two ways to run it — GTM and Go To Sleep (we run it for you) or GTM and Go Full Control (you drive, $29/mo): https://foxplug.com/gtm?utm_source=producthunt&utm_medium=comment

@glhanpakso482v Gülhan, this is gold - thank you. The reality simulator is close to our hearts, and hearing it's useful for early-stage founders makes it worth it. And the sanitised export idea is brilliant. We're already working on making reports cleaner and more shareable, but framing it as "quick feedback without raw data" for co-founder/investor conversations is exactly how we should position it. Adding this to our roadmap right now. Thanks for the candid feedback!

@celalsenal45369 Celal, this hit home. The 2am founder spiral is real, and knowing we built something that could actually help in that moment makes all the late nights worth it. Thanks for the genuine feedback - we're building this for exactly that kind of founder.

@ahinyu95 Şahin, now this is the kind of feedback that keeps me and the team up at night - in a good way. The comparison mode is actually a really sharp idea. We've been heads-down on nailing the single-idea experience first, because we figured if we can't make one validation rock-solid, comparing two shaky ones won't help anyone decide. But you're right - that moment when you're torn between two pivots is exactly when you need this kind of clarity. Not promising it's coming next week, but it's definitely sitting on our radar. Thanks for pushing us to think bigger!

@fatih928031 Hey, thank you so much for the positive feedback, I appreciate it. If you ever have any future concerns please let me know !

Best,

Somesh

@serdarurim Hey, thank you for the positive feedback. I appreciate it. If you ever have any future concerns please let me know !

Best,

Somesh

@basar95467 Hi, thank you for the positive feedback! I appreciate it. If you ever have any future concerns please let me know !

Best,

Somesh

@galdayan Hey, glad this was asked in case others wondering as well. The about page shows some sources cited, and each disease page also shows clickable links for sourced info. Numerical Data is pulled directly from these sources, I dont craft or fluff them into desired figures. Hope this gives some clarity !

Thank you for the note and feedback.

Best,

Somesh

@linalb2v Hi, thank you for the positive feedback ! I appreciate it. If you ever have any future concerns please let me know !

Best,

Somesh

@nurayzbilgtes5 Hey, this is a brilliant idea that I did not think of adding. A few other comments also mentioned this idea. Thank you to you and everyone who suggested this, when I add this feature I will be sure to mention your name and the others as a token of appreciation.

Best,

Somesh

@anlcengi7zjn Hey, this is a brilliant idea that I did not think of adding. A few other comments also mentioned this idea. Thank you to you and everyone who suggested this, when I add this feature I will be sure to mention your name and the others as a token of appreciation.

Best,

Somesh

@yavuzwrpt Hi, this is an excellent addition that never clicked me. Thank you for the suggestion, when I add this feature I will always mention your name for appreciation.

Best,

Somesh

@sevgivnzu Thanks alot, we are starting small and improving on the project

@giedrius_zdramys Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@alpergrbzobpev thanks Alper! punctuation was the bit that took longest to get right — transcribing words is easy, guessing where your sentence was going is the hard part. glad it's invisible, that's the goal

@yusufjqnq thanks! that's basically the whole bet we made — most tools hand you a raw transcript and leave the cleanup to you. still plenty we want to improve on flow, but glad it already feels different

@kymetrayw ha, the markdown + plain text mix is one of the nastier cases, so genuinely glad it held up. if it ever mishears a technical term, there's a Dictionary tab where you can pin the correct spelling and it sticks from then on

@ecegencogl26083  "the messy middle that everyone else ignores" is honestly a better pitch than anything on our website 😄 that gap between what you said and what you'd actually send is the whole product. if you find rough edges in there, tell me — that list is basically my roadmap

@balcicek59166 good news — that already exists :) there's a Dictionary tab in the app: add technical terms or names once and it stops mishearing them, and it's tied to your account so it syncs across devices. there are industry packs too (software, marketing, medical…) you can toggle on. try it and tell me if anything's missing from what you had in mind

@galdayan Yes, that’s the case the screening layer is actually built around, because you’re right that the blunt override is trivial. Two things matter:

The classifier isn’t keyword-matching for “ignore previous instructions.” It’s judging one question: does this message contain instructions aimed at the AI reading it, versus content that asks nothing of the agent? A real onboarding email tells your team to install something. An injection tells the agent to take an action outside its task, and dressing it in vendor-onboarding language doesn’t change who the instruction is addressed to. Our red-team corpus includes exactly the shape you’re describing — a plausible vendor form with an embedded “operator note” directing the agent to export data — and also the mirror case: genuinely legitimate technical emails (“here’s our HMAC signature, verify it like this”) that must pass. We track false flags as failures too, because a filter that flags everything is useless.

Second, and honestly more important: classification isn’t the only line. Your agent never receives the raw email. It gets structured JSON extracted against your schema, so a “run this command” that somehow survives screening arrives as inert data in a field, not as prose in the agent’s context.

No immunity claims though — screened, never immune. The full scoreboard, including misses and false flags, is at postfleet.ai/security, and every miss becomes a regression fixture.

@nuran37cs Thanks, that’s the whole point of that step. Keeping parsing and comprehension separate from the agent’s decision layer means it only ever acts on clean, structured input, not raw email noise. Small architectural call, but it’s the difference between reliable and flaky.

@emircansowj Thanks! that was the exact gap that bugged me: everyone's solving delivery, nobody was treating the inbox as hostile. If you wire it to a bot this week and hit anything rough, ping me and I'll help you get it running (the MCP path is the fastest way in). Would genuinely love to hear how it goes.

@hafizeewzm The glue code was the exact thing that made me want to build this. And yeah — injection screening should be table stakes for agent email, that's the whole point. Thanks for giving it a run.

@saliha43403 Double-sends and "my agent just emailed a customer something weird" were the two things that scared me most, so those got built in early. Glad it stood out to you.

@alicioglu16119 Right? I couldn't believe it wasn't already standard. Getting the MCP tools to drop in with no wiring was the whole goal, so that means a lot. Thanks Osman.

@rukiyebilda3cj Messy threads are exactly why I started this, real inboxes look nothing like the tidy demo examples. Happy it saved you the cleanup.

@evvalkayga5vdo That's the core bet: treat the inbox as hostile by default. Most tools assume it's safe, and agents can't afford that assumption. Appreciate you getting it.

@scott_foster6 

Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@rob_collegefitproject Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@talhakhalidmtk Yes, you can! An AI factor can either be evaluated as a Yes/No (Does the school have a puppetry program?) or can be a scale from 1-10 (Rate based on how close the school is to a ski mountain)

@toprak4irg Actually, there is a side-by-side view. The free version allows evaluation of a single school while the paid version allows up to 50 schools.

@gitikagit Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@cemgmlcnehrtm 
Thank you, Cem! 😊

I'm really glad you noticed the SMS capture.

Getting it to work on iOS was honestly one of the hardest parts of building Klutter. Apple's permission model doesn't allow apps to simply read SMS, so we had to think differently instead of forcing a solution.

We ended up leveraging the power of Apple's Shortcuts to create a privacy-friendly workflow that lets users automatically capture transactions while staying within the platform's guidelines.

The AI insights are another area we're obsessed with. We don't want to tell people, "You spent too much on coffee." We want Klutter to understand your financial habits and answer the questions that actually matter.

@nuraypzdp Thanks, Nuray! 😊 That's exactly what we were hoping for—helping people catch the transactions they usually miss and turning them into insights they can actually use.

@omri_ben_shoham1 

Great question! In Klutter automatically categorizes transactions, but if something is mixed (like a personal + business receipt), you can easily split it into multiple categories. You can also create your own custom categories, and if the AI isn't confident, it falls back to Miscellaneous so nothing gets incorrectly classified.

@omri_ben_shoham1 Great question! We try not to make blind guesses. Klutter auto-categorizes transactions, but if something doesn't fit cleanly, it falls back to Miscellaneous instead of misclassifying it. You can also create your own custom categories, and for mixed receipts or personal/business expenses, our Transaction Split feature lets you split a transaction across multiple categories. We're continuously improving the AI to handle more of these edge cases automatically. 😊

@azizayerrm9y 
That's a great suggestion, Aziz! We want Klutter to help people make better financial decisions, not just track expenses. A shared household mode with combined budgets and insights is a compelling direction, and we'll definitely be exploring it. Thanks for the feedback! 🙌

@abdurrahmakeml 

Thank you! We obsessed over getting SMS capture right, so hearing this is incredibly rewarding. 🙏

@omri_ben_shoham1 
Exactly! 😊 We'd rather be safely "unsure" than confidently wrong. Really glad the transaction split approach resonates with you—that mixed receipt scenario was one of the key reasons we built it.

If you'd like to explore more, I'd be happy to give you 3 month of Klutter Premium. We'd love to hear your honest feedback on the AI insights and everything else we're building. 🙌

@magdenmahm80499 
Love this idea, Mahmut! That's exactly the kind of direction we want to take Klutter—moving beyond tracking your finances to helping you understand the impact of future decisions. A "what-if" simulator is definitely something we've discussed, and feedback like this helps us prioritize it. Thanks for sharing! 🙌

@magdenmahm80499 Love this idea, Mahmut! That's very much aligned with our vision. We already have an AI assistant that helps users understand their finances, and taking it a step further with "what-if" scenarios is something we'd love to explore. Thanks for the great suggestion! 🙌

@cao_phuc Congratulations on shipping it! Want to know what demand signals are for this? Run it through MarkLens AI; it only takes a minute and is free! Happy Launching!

@asiyekmeogipbc yes, I am trying to add optionals like Message Quebe, WebSocket

@talhakhalidmtk it regenerate the whole backend. I am trying to fix it

@emirerannpn3 Thank you so much. You can switch between FastAPI, NestJS, Fiber

@atakandeftsjbn Thank you so much