PH热榜 | 2026-07-12

@sherina_chen Congrats on launching Miora! The part that stood out for me was the problem - teaching a tool your preferences from scratch every time is a tax people are paying with AI creative tools right now.

Memory is what Miora's all about - that's the kind of differentiator most tools would love to have, and it's currently buried under the deliverables.

Who do you picture opening this first - an agency creative director, or a solo brand builder?

@zack good to hear. the reason i ask about specialist visibility specifically is that when the pipeline gets faster, review debt piles up faster too. teams reviewing 40 assets a week can't debug what went wrong without knowing which agent decided what. curious what the roadmap looks like for that part.

This looks insanely useful. Jumping between tabs and constantly re-prompting my style rules is the worst part of my workflow right now. Having an agent that actually remembers previous briefs is huge. Gonna go use my free credits now. Congrats!

@uddipta Appreciate that. We kept feeling that "trust me, the AI remembers" wasn't enough. If memory affects the output, people should be able to inspect it, edit it, and decide what stays.

@uddipta You put it really well. The trust relationship changes when memory is inspectable and editable. Miora can organize memory automatically in the background, but users should be able to see what it learned, remove what’s wrong, and add specific rules when needed. Memory should feel like a creative system you own, not a black box.

@uddipta Such an insightful comment, Uddipta! "Trust" is such a crucial word for us. We strongly believe that true creative tools shouldn't require blind faith in a black box. We designed Miora to earn your trust not just through a hands-on, transparent working mode on the canvas, but also through consistent reliability when executing your specific vision. Letting you inspect, tweak, and own those rules is the only way to build a real partnership with the AI rather than just fighting against it. Thanks for the support!

@felix_harper That's the shift we're excited about too.

For a lot of creative work, the real cost isn't generating the asset. It's re-explaining the context, preferences, and decisions every single time.

We're hoping Miora can become something that grows alongside the creator, instead of resetting back to zero every session.

@felix_harper Exactly. The goal is for Miora to build on what you have already made and decided, instead of making you repeat your taste, references, and constraints every time. like a teammate

@felix_harper btw
That has been one of the strongest reactions from our beta users: after working with Miora’s Agent for a while, they do not want to go back to one-shot generation tools that make them start over every time.

@artstavenka1 Great question! Updating the anchor doesn't automatically redo everything. The new direction can be saved into Miora's memory, and creators can choose which downstream assets they want to regenerate.

We believe creative teams should stay in control — sometimes you want the whole system to evolve, and sometimes you only want to adjust one branch~

@artstavenka1 Thanks for the kind words and the brilliant question, Art! The short answer is that we deliberately avoid forced auto-propagation. Miora is designed as a fluid canvas rather than a rigid, top-down workflow tool. There isn't a strict "downstream"—you can use node A to generate node B, and then actually use B to iterate back on A. We built it this way because we strongly believe that in the age of AI generation, the "human touch" found in step-by-step fine-tuning and curation is more precious than ever. Blindly auto-updating child nodes often destroys those intentional creative choices. However, if you do want that automated pipeline effect for a specific task, you can easily save your mature process as a reusable Skill!

@artstavenka1 You touched on a really important point. Miora isn’t designed as a traditional node-based workflow where changing one upstream node mechanically re-runs everything downstream.

The anchor is more like a shared creative direction: the approved intent, visual logic, references, and decisions behind the work. If you later realize the anchor is slightly wrong, you can update that direction, and the agent can help carry the correction into related assets across video, UI, or 3D.

The goal is not automatic destructive re-propagation, but intelligent revision. The agent should understand what changed, what needs to be adjusted, and what can stay intact, more like working with a creative teammate than operating a pipeline.

@cnurettin33910 Thanks so much for trying Miora and sharing this!

This is exactly what we’re building toward and really glad the Skills and editable Canvas are helping make your workflow smoother.

Would love to see what you create with Miora and hear any feedback as you keep exploring!

@cnurettin33910 Thanks so much for trying Miora out, Nurettin! We strongly believe that maintaining context shouldn't require manual copy-pasting, and organizing thoughts shouldn't feel like a tab-management simulator. Really glad to hear the canvas is bringing some visual sanity back to your creative process!

@cnurettin33910 This is exactly what we heard a lot during our beta. Once people use Miora for a while, it becomes hard to go back to one-off generation or node-based workflows.

The value really shows up when creative decisions start carrying across assets naturally: colors, style choices, brand rules, references, approved directions. You spend less time rebuilding context and more time actually shaping the work.

@omri_ben_shoham1 Couldn't agree more. Especially for teams, editable memory feels much more useful than magical memory.

@omri_ben_shoham1 Really appreciate that!

We think creative teams need more control, not just "trust the AI." Making memory editable means it's easier to refine, share, and keep everyone aligned instead of hoping the model remembers the right things~

@omri_ben_shoham1 Spot on, Omri! This touches exactly on a major pain point we observed in real creative workflows.

Memory is fantastic, right up until the moment you need to pivot. In actual production, there are always times when you have to partially or completely scrap a previous style and take a new direction. In those situations, a "magical" black-box memory becomes a nightmare—it stubbornly drags you back to the old context, and you end up fighting against the tool.

By making memory explicit and editable, creators can literally just delete or toggle off the outdated rules. You keep the foundation that still works, and toss the rest. Really appreciate you highlighting this practical difference!

@thenameisarian Great question! That's actually a direction we're really excited about.

Today in Miora's Free Canvas, you can see assets evolve step by step and jump in to edit any part of the process directly on the canvas, so creation feels collaborative rather than like a black box.

You're also not locked into a fixed workflow, you can decide which specialist handles which task and shape the process as you go.

@thenameisarian Right now you can already see what each specialist is doing in the conversation and follow how assets evolve on the canvas.

So if something breaks, you can usually tell where it broke.

The more explicit review workflow you're describing for brand teams isn't there yet, but honestly that framing is kind of brilliant 😄

"Don't blame the whole pipeline, point to the step that broke" is probably a better way to describe the problem than we've been doing internally.

Mind if we steal that? Would love to keep you posted as we build toward it.

@thenameisarian Because a real Agent is handling the task, you don’t need to worry about the process being hidden. Unlike traditional pipelines or workflows, you can freely direct the Agent or ask questions to get exactly what you need！

@luke_pioneero Yeah this was the thing that kept us up honestly. The trick is the consistency doesn't live in the models, it lives one layer above them. Whatever you upload (your product, palette, the rules) gets pinned in memory and pushed into every step as hard constraints, so it doesn't matter if it's the image model or the video one doing the work, they're all drawing from the same anchor. Otherwise, you just get 5 pretty assets that look like 5 different brands

@luke_pioneero Building on Sherina's point about the memory anchor, this is exactly why we don't just generate everything simultaneously in a black box. The workflow in Miora usually starts with establishing a strong core asset—like a key visual or character design. Once you approve that node, its specific stylistic DNA gets locked into the agent's memory. When you then branch out to generate a video or a 3D object, the agent isn't starting from scratch; it's explicitly referencing that approved anchor node. The underlying models might be different, but they are all forced to obey the same master reference you established.

@luke_pioneero Great question. The key is that consistency lives above the individual models. The agent keeps the approved direction, character traits, references, and design rules as shared context, then adapts them for image, video, UI, or 3D generation.

Different models may produce the assets, but the agent is carrying the same creative intent across them.

@sherina_chen also, when verifying the video settings, I couldn't figure out how to alter them. I could either Confirm or Deny or "type additional requirements", but typing them didn't seem to make a difference.

@leo404 You’ve landed on exactly the problem we designed for. Miora has two kinds of memory:

Personal memory lives with your account and can carry context across projects. Project memory stays inside that project, so it can hold a client’s brand rules, taboos, key decisions, and progress without bleeding into your personal work.

Skills are not limited to your own account. You can use them yourself, download and share them with teammates, or publish them to the marketplace for other creators to use.

@leo404 Memory is just the one of many exciting features coming to Miora. We’re rethinking creative generation around a true Agent, with the goal of transforming how people create while dramatically lowering the barrier to entry. Much more is coming.

@sabber_ahamed To clarify, a Skill in Miora functions as a shareable SOP rather than a continuously evolving memory. It doesn't automatically drift in the background as you continue to edit, nor is it rigidly locked to your very first brief. Instead, it acts as a snapshot. When you finally decide to save a process into a Skill, the system looks at your entire workflow and summarizes the final, matured style you landed on at that exact moment. If your taste shifts again later in the project, you would simply save that new, updated process as a fresh Skill.

@sabber_ahamed That’s a really sharp question. The distinction is deliberate: Skills stay fixed, so they do not quietly drift as your taste changes. If you want to update one, you can ask Miora to revise it, but that is an intentional change.

Memory is different. It can evolve with the current context and your history, correcting itself as it learns more about your preferences. You can also edit it directly whenever you want.

@sabber_ahamed Memory and skills is just the one of many exciting features coming to Miora. We’re rethinking creative generation around a true Agent, with the goal of transforming how people create while dramatically lowering the barrier to entry. Much more is coming.

@sabber_ahamed That is a great technical question! To clarify, a Skill in Miora operates much like skills in other AI agent products—it is completely stateless. The baked memory and specific anchor nodes do not travel with it. Instead, a Skill is designed to summarize your process and capture your workflow, essentially acting as a SOP. When you share it with a teammate, you are sharing the exact recipe, which they will then apply to their own specific anchors and canvas memory.

@rajveer_raj That is a very fair point about building creator confidence. Right now, while you cannot export the entire Miora workspace as a single offline project file, we've made absolutely sure that no creative asset is ever locked in. You can export every single piece of content you generate on the canvas—whether that's images, videos, UI components, or 3D models—in standard industry formats.

Our current philosophy is to make Miora the ultimate upstream generation hub where you nail down the vision, giving you the freedom to pull all those individual assets into your traditional downstream software for any final, structural editing.

@rajveer_raj 

Every asset on the canvas exports in standard formats, whether that's images, videos, UI files, or 3D assets, so nothing gets trapped in a proprietary format.

Projects can also be shared via link, making it easy for collaborators and stakeholders to revisit the full context of the work, not just the final outputs.

We think creators should own their work, not the tool that helped create it.

@rajveer_raj Good point. All assets created in Miora can be exported, and keeping projects editable over time is important to us. We’d love for you to try it and share what else you’d need to feel confident using Miora as your long-term creative workspace.

@jody_l_wyatt That's exactly the problem we're interested in. Generating options is getting easier fast. Remembering why a decision was made feels much harder and much more valuable.

@jody_l_wyatt Totally agree. The hard part isn't creating more options, it's maintaining creative consistency and delivering reliable, aligned outputs over time. That's something we've been thinking deeply about, and it's the kind of creative memory we're building with Miora.

@jody_l_wyatt Spot on, Jody! You’ve highlighted exactly why the traditional linear chat interface often fails real creative work. When you try to iterate inside a chat box, the AI tends to get stuck in a rut, getting progressively worse as you give it more feedback, and you can't even roll back to a previous good version. That’s why we built Miora on an infinite canvas—it lets you freely branch, compare, and merge different nodes. When you finally approve a specific direction, our memory layer captures the exact WHY behind your choice, acting as a stable anchor that carries that approved style seamlessly into other mediums like video or UI without losing the essence along the way.

@jocky Love this idea. A lot of creative work ends with client review anyway, so having a cleaner way to present selected parts of the process makes a lot of sense.

@jocky Great suggestion, Jocky! Bridging the gap between the creative process and client deliverables is exactly the kind of professional workflow we want to support. Turning curated canvas nodes into a streamlined presentation makes total sense for agency and studio use cases. Really appreciate you sharing this, it gives us a great direction to explore!

@carlvert Haha that's exactly the kind of brief we'd want people to throw at it. Curious what you'd think after trying it.

@carlvert Thanks! That’s actually a great stress test. Keeping one character’s identity consistent across illustration, UI, motion, and 3D is exactly the kind of challenge we want to tackle. Would love to see what you create with it!

@orman_canida This is exactly how we think about it. Every rule in memory is visible and editable — you can add "always keep this brand color," remove something that's drifting, or correct how it reads your style. It's a creative system you steer, not hidden personalization you inherit. Appreciate you calling that out

@orman_canida Exactly. The biggest problem with "magical" black-box memory is that it actually works against you when you need to change directions.

In real studio production, you frequently need to partially or completely overturn a previous design. An invisible memory will just keep interfering and messing with your new concepts. Making memory editable means you can instantly clear out the old rules and pivot without fighting the AI. Thanks for seeing exactly what we were aiming for!

@orman_canida Yes! We don’t want memory to feel like hidden magic. In Miora, memory is organized automatically in the background, almost like how the brain consolidates thoughts while dreaming at night.

But the important part is ownership. Users should be able to inspect it, edit it, add rules, or correct the agent when needed. Creative memory should be something the user can shape, not something silently controlled by the model.

@sandy_liusy Thanks! yeah that's the part I'm personally most excited about. The thing you used to re-explain every single time just... becomes a Skill you reuse. Feels obvious in hindsight but it took a while to get there

@sandy_liusy Thanks! Really glad that resonated with you~

@sandy_liusy Thanks Sandy! Exactly. We hope Skills and memory can go beyond reusable instructions and become a way for the Agent to truly learn how you create. The more you work together, the less you need to explain yourself again.

@charlenechen_123 Thank you! That feeling of having everything live on one canvas instead of jumping between five different tools was exactly what we were chasing

@s_cen In Miora, memory isn't hidden away in a black box. We separate personal memory from project memory, and both are visible and editable by the user.

You can also turn memory off entirely when you want to work from a clean slate.

The "why was this memory recalled for this generation?" part is a fascinating direction though. The moment AI starts having memory, it probably also needs receipts.

@lily_liu8 Exactly. One of the early use cases we kept seeing was teams trying to make sure the product UI and the launch visuals felt like they belonged to the same story.

Turns out consistency is easy to say and surprisingly hard to maintain

@lennoxbeflying You are exactly the kind of creator we had in mind when we split project memory from personal memory.

The idea is that a shared Skill carries the workflow and the intent behind it, while each creator still brings their own context and references into the project.

So if your Skill says "keep the playful illustration style, the soft gradients, and the visual language from Project X", those rules travel with the Skill. The personal history behind why you like those choices stays yours.

We like to think of it as sharing the recipe and the taste profile, not your entire kitchen.

@omri_ben_shoham1 That’s a great point. Memory system looks at the user’s current input and weighs both strong and weak signals when deciding whether to add or update a memory. An explicit correction carries more weight, while smaller signals can indicate that a preference may be shifting.

We’ll keep refining how Miora interprets those signals based on user feedback. If you notice situations where it reacts too strongly or misses a change, we’d love to hear about them.

@mingyouagi Exactly, and it is more than putting the assets on one canvas. Miora’s agent sees the work in one shared context, so it can follow the connection from a key visual to motion, social, and UI without making you re-explain the brief every time.

Project memory carries the important context across new conversations too, such as your logo, brand rules, and key decisions. That continuity is where the handoffs start to feel much less painful.

@mingyouagi and memory is just the one of many exciting features coming to Miora. We’re rethinking creative generation around a true Agent, with the goal of transforming how people create while dramatically lowering the barrier to entry. Much more is coming.

@chenlh Congrats on the launch 🚀

I love the idea of search evolving from "finding information" to "getting a working app." That's a pretty compelling shift from reading answers to interacting with them.

I'm curious, what's the most unexpected prompt that JustVibe handled surprisingly well? Was there a user query that made your team realize, "Wow, this is exactly the future of search"?

Wishing you an amazing launch. Excited to see where JustVibe goes! 🔥

@chenlh i love this website! Also, is there a way to submit my website into the results?

@morgan__harriss It's great to hear and thanks for your support! @JustVibe shows instant full app experience for a wide range of topics, like mood board creation, home design, outfit explorer, and a lot more you can explore based on your interests!

That's a good insight @thenameisarian I believe every app should be reusable, shareable, and should even encourage for collaborations.

• For any app you created on @JustVibe , it's saved to your "Library". You may reuse or share with anyone you'd like. It's yours, forever.

• For an app you discovered but created by others, you may still save to your "Library". What's more interesting? You can edit this app just by chatting and this edited version becomes your own app. You can think of this as the open source community for apps, where contributing is as easy as chatting.

@aria_turner The apps that involve planning (like a trip planner app) usually have a "save" or "summary" button that would save your app summary (it can be a trip itinerary for a trip planner, or a food recipe for a recipe finder) into you "Library". These summaries are yours to keep. You can come back to them any time you want. Exporting your plan to your calendar app (like google calendar) is coming soon.

Thanks @vahid_davoudi I believe the endless app customization is what leads to the ultimate personalization on @JustVibe. You can edit any app (no matter who the creator was) by selecting a component of the app and putting a comment. You can edit any edited app, with unlimited edits you may perform.

@doganakbulut Good question! The apps that produce artifacts (e.g. a trip itinerary) have show summary / share / export functionalities that allow you to seamlessly share with friends or export to a third party service through your device's native integrations.

That's a good question@sevim1088807

• All the apps created for you will be stored into your "Library", and by default will keep running forever. You always have the option to delete any app from your "Library". The app would be entirely wiped from JustVibe when deleted.

• How the data within the apps are handled is different app-to-app. Some apps like a security key generator run 100% in your browser and JustVibe never has access to these data. Other apps like travel planner allows you to save your travel plan data into your "Library", but does not keep any data after your app usage if you do not choose to save.

That's a good question@rod_sodax Apps on JustVibe are not just UI. Apps are built with sophisticated backend, with the capabilities to search / browse the latest web, to generate creativity assets, to fetch the real time data from stock market, to access the massive commerce inventories, and many many more. So when an app loads for a user, it leverages the capabilities it's armed with and provides the most useful information it could to the user.

Thanks@uddipta Apps never expire on @JustVibe. You can save any app into your "Library". You can go back to any app in your "Library" any time you want. Even if you just have the url to this app, the url would work for ever.

That's a good point@victoria_brooks I believe a prompt is just a starting point of a custom app. What enables the ultimate customization on @JustVibe is endless edit: You can easily select any component on the app and put in a comment on how you'd like to edit. There is no limitation to how many time you can edit an app. You can see the entire edit version history and customize endlessly to your exact need.

@avantigrowthlab Thanks for your support and that's a great question! Apps and app data can both be persistent, but in different ways. All the apps created for you and all the apps you saved are kept in your "Library". It's yours to reuse, to share, to edit, forever. The app data are not persistent automatically, but there are controls inside the apps you can use to store the data or an artifact into your Library, like the trip itinerary from travel planner app and the living design plan from a home design app.

Thanks! @ryancheng When trying to match a query in the existing app library, we primarily look at 1) if what the app was built for matches the query's intent and 2) if the app satisfies all the requirements from the query (e.g. a query may say "allow me to specify my interests like food and culture"). JustVibe would serve you an existing app if it perfectly match these requirements, otherwise you can choose to build one specific to your need or chose from a list of existing apps that are your closest matches.

Apps can be shared and reused across users freely. You may even create an edited version of an app created by others for your specific need!

@crystalmei Good question! Many searches on JustVibe (like the ones with vague intent) do not land you on an app directly, but instead the result page includes quick answers on different directions for the topic, and suggestions on the interactive apps that you may use.

Thanks @leo404 that's a great question!

When you share an app with your friend, your friend gets the same app, but it's like a forked version of the app. Both you and your friend can create your own edited versions on top of this app. But your friend's edits would never impact your apps.

Whenever an app is created for you, it's automatically saved to you "Library". It's yours forever. You are free to reuse, to share, to create edits. @JustVibe keeps the entire edit version chain so you may go back to any version that you want!

@omri_ben_shoham1 The summaries that are exported today are static as they stay on third party platforms, but if you go back to the same app again on @JustVibe and the app would try to fetch the latest and the most useful information live for you.

@john_marker3 Thank you so much for sharing the feedback! The header was designed to disappear when you are using the app and to re-appear when you scroll up past the top of the app. It does create a confusing moment for you and we will look into this.

@henryslang Very interesting point!

Apps built on @JustVibe have the capabilities to browser and use the web in real time, to conduct deeper research on topics, and to perform third party integrations (e.g. to get hotel accommodations). Most of the apps built on @JustVibe today include links if they would help with the user journey, e.g. the links to travel destination websites, the links to hotel accommodations (try this query: "hotels in Paris that are close to metro"). If you are seeing links missing but helpful on an app, you can always "edit" the app asking it to include a link or reference for you. Your point on making the results trustworthy is a really good one.

That's a really good point! @reda_roqai_chaoui 

On @JustVibe, not all search queries would lead you to an app. We understand if the user query intent is better fulfilled with an interactive app or a quick answer. Try search for something like "when is world cup final" on JustVibe and an instant quick answer instead of a full app would show up.

@hannonc Thanks for your support, Hannon! Instant interactive experience + Endless customization is exactly where I believe consumer software should be heading towards.

@chielephant Good question! For the apps instantly set up for your searches, you can always get back to this app by either 1) use "save" to store into your Library or 2) simply go to the same url. For your custom built / edited apps, they are already in your "Library" when built.

No matter how an app was built, you can always reuse, share, or create your own edited version. It's yours to keep, forever!

Thanks @galdayan that's a good question.

On @JustVibe, apps remain unchanged, while app creation / edit process improves over time. When you create an app, we don't want you to come back tomorrow and find out the app gets changed. Reusability is our promise.

The app generation improves over time and works with all apps, no matter when an app was created. So if you want to edit your favorite app created six months ago, you are leveraging better models and better app generation process while at the same time they work seamlessly with your old app.

Thanks @henryslang! I believe the most frictionless consumer platforms do not put a pay wall in front of their users. Even though JustVibe is not monetized today, there are countless experiences that allow users to shop. The plan is to work with commerce partners without any changes to the user experience.

@ilko_kacharov Thanks for your support! The shift from finding matched webpages, then to information gathering, now to Get Things Done is where I believe the ultimate search experience should head towards.

@sabber_ahamed When finding a match from the existing app library, we primarily look at 1) if what an app was built for matches the query's intent (e.g. to create a travel itinerary for the next trip) and 2) if an app satisfy all the requirements from the query (e.g. "allow me to specify my interests like food and culture" in the query).

Just like Google has a huge index of the pages on the web, @JustVibe has an index of a massive app library.

@nelsonsilvadev Thanks for your support! There is a big distinction between helping you get things done vs. giving you information to read. The full app experience @JustVibe is envisioned address a wide variety of the searches much better. Try out the ones on JustVibe and try out the ones that never worked elsewhere. I would love to hear about your feedbacks!

@priya_kushwaha1 thanks priya! the reproduction is the saved artifact. you get a receipt URL, a replayable trace of the exact out-of-order sequence plus what your handler did, and the workflow + delayed-delivery scenario that triggered it is a re-runnable check you can drop in CI. that's your regression.

not auto-written into your repo as a test file, it's a re-runnable proof you keep and rerun. delayed/out-of-order delivery is one of the lifecycle failures the sandbox simulates deterministically, so you can reproduce that clerk case on demand instead of waiting for prod to bite you again.

honest bit: one-click "save this + push to shared library" is the direction, not fully there yet. that's exactly what i'm building toward.

@priya_kushwaha1 thanks Priya. the reproduction itself is the saved artifact. when it catches that clerk timing failure you get a receipt, a replayable trace of the exact sequence and what your handler did, and the workflow plus scenario that triggered it is a re-runnable check you can drop into CI. thats your permanent regression, you keep it and rerun it.

its not auto-written into your repo as a test file, its a re-runnable proof you own. one honest note since it came up elsewhere in the thread, true out-of-order as its own knob isnt in yet, it comes out of variable delivery timing today, but the way you save and rerun it is the same either way.

the part thats not automatic yet is one-click save this novel failure and push it into the shared library so the agent doesnt reintroduce it later, thats the direction im building toward, being straight about that.

BTW — you can try it headless in Claude Code, Cursor, or Codex via MCP. One-line install, no keys or accounts, and the API is fully documented.

Here's a starter prompt to try:

./fetchsandbox "test my Stripe checkout — customers are getting charged twice. reproduce it and prove the fix."

@rnagulapalle congrats! btw is the failure library stored completely locally inside the mcp server or hitting your cloud database ?

@ryan_davis23 thanks ryan, and yeah that setup-mode currency 400 is exactly it. test mode passes clean, the mode/param interaction only bites on a real card, and you don't find out until prod. that class of thing is what the stripe library carries.

on seeded vs learned: today it's curated from real integration failures and documented behavior, but nothing enters until it's reproduced. a buggy handler and a fixed one have to actually diverge in a sandbox run, not just "the docs say this can happen." so it's behavior-grounded and proof-gated, not just a wiki.

the auto-learning piece, failures from live integrations flowing back in on their own, that's early. that's the compounding thing you're pointing at and it's where this goes. curation is still more hands-on than i'd like right now, being straight about it.

glad you're wiring it in this week. if anything's rough, reply or DM, i want the sharp edges. fast first win: point it at a stripe flow and have it prove the webhook-retry/idempotency path before you merge.

@nitesh_kumar98 thanks man.., request worked, webhook bit me later is the one that gets everyone. you don't see it until a customer emails you about it. being able to recreate that on demand, duplicate delivery, late event, dropped, without waiting for prod to bite you, that's the whole point. give it a spin and

@uddipta thanks man ., and yeah a few people landed on this exact thing which tells me it's the real hard part.

the intent is that patterns carry conditions, version, config, auth model, so "changed in v5" scopes to <v5. old version still gets the warning, v5 doesn't get a stale alert. version is just another condition on the pattern, not a global flag.

honest status: the condition mechanism exists but version-range partitioning is shallow right now. that's the next thing the shared library has to get right, and you're correct it's the hardest part to hold over time.

@uddipta thanks man.., and yeah a few people landed on this exact thing which tells me its the actual hard part.

the way its meant to work.. a pattern carries its conditions with it, which version, which config, which auth model, so something that changed in v5 gets scoped to below v5. someone still on the old version keeps getting warned, someone on v5 does not get a stale alert they don't need. version just becomes another condition on the pattern instead of a global on-off.

honest bit, that condition mechanism exists but version-range scoping is shallow right now, its the next thing that has to get solid. you're right its the hardest part to keep right over time, a shared library that cant tell whos still affected is just noise.

@andrasczeizel thanks man.. 100% agree..and on global vs scoped, it's both. the global layer is per-API: when you test stripe you inherit the known ways stripe breaks, webhook dedup on the wrong header, a PaymentIntent stuck at requires_capture, duplicate delivery on retry. you don't rediscover those. that library compounds the more integrations run against it.

the scoped layer is your code: the reproduce, fix, rerun happens against your handler and your routes. global tells the agent what to look for, the sandbox proves whether your specific code survives it.

honest state: the global per-API library is real and shipped. the cross-project learning piece, where a failure one team surfaces flows back into the shared graph automatically, that's the direction we're heading, not a solved thing yet

@chielephant this is basically what i built it for so i'll answer straight.

the intermittent break is the core use case. those are impossible to reproduce because they're timing and state dependent, a retry hitting stale state, a duplicate event, a slow response tripping a race. in the sandbox you turn those conditions on deterministically, so the once-a-week 500 becomes something you can trigger and watch fail on demand instead of waiting for prod to show you. that's the "remembers what breaks" part, it's a curated set of failure modes per API.

webhooks and callbacks, yes, fully covered, that's honestly where most of the value is. duplicate deliveries, retries, out of order, dropped events, you replay them and see if your handler double-processes or corrupts state.

the provider-version-drift one is the honest gap. we catch a shape mismatch within a run if our model of the API is current, but auto-detecting that the live provider moved on its own is still on the roadmap.

@alex_watson2110 thanks, yeah that retry-that-fires-twice and the out-of-order webhook are exactly the two i kept getting burned by, thats the whole reason this exists. appreciate you getting it.

@hi_i_am_mimo good questions, and using determinism as your merge gate is the right call, so i'll be precise.

where the library lives: it's server-side, not per-project. when you connect over mcp you're talking to our backend. you're not recording your own scenario library locally, you're pulling from the curated one we ship per API. runs are keyed to a sandbox id you control, but the failure definitions themselves live on our end.

determinism: named workflow + named scenario is repeatable, same inputs replay the same way, and you get a receipt url as the artifact to attach. duplicate/retry (same event id redelivered) is fully deterministic today, you can gate CI on that one right now.

honest caveat on your exact example: out-of-order isn't a first-class pinned fixture yet. ordering currently falls out of variable timing rather than a strict "deliver B before A" replay. duplicates, retries, stale state, deterministic. precise out-of-order as a pinned sequence, not yet, that's the next one i'm adding.

so if your gate is retries and duplicate delivery, it's ready. if the specific gate is deterministic out-of-order replay, i'm not going to tell you it's there when it isn't.

@henry_s_jung right now its focused on the hard and lifecycle failures, not the quiet drift you mean.

the shape thing, within a run we validate responses against the contract, so if your handler assumes a field thats missing or wrongly typed, that shows up. but that only catches it if our model of the api is current.

the case you actually care about, the real provider silently changing shape or a model name that stops resolving one day, we dont auto-detect that yet. we test against a sandbox, so we catch the mismatch only if the sandbox already knows the api moved. noticing the live api drifted on its own is the piece im still building, and honestly its the one im most focused on next.

@german_merlo1 thanks man.. appreciate the kind words.. this community was very supportive... with kids/fulltime/gridning weekend. was bit challenge literally slept like 4 hrs avg haha. now this results give me confidence !!

@akbar_b good questions, both hit the same edge.

first one, it's more guided than a raw menu today. the agent doesn't freely enumerate the whole failure library and pick, but it's not just running whatever i configured either. you describe the symptom or bug you're worried about, the router matches that to the right workflow plus scenario, and you can also pass a scenario by name directly. what's not there yet is a clean "list all injectable failures for this API" call the agent can just browse. reasonable thing to expose, on the list.

second, the library is per-API not per-project right now. you inherit the known breaks for stripe/clerk/etc the first time you touch them. the per-project piece, what broke in your specific app, is early.

and the auto-replay-as-regression-gate, honestly not automatic yet. today a known break is a re-runnable workflow plus scenario you can drop into CI, so a regressing fix does get caught, but you're wiring that gate yourself. it's not auto-replaying on every change on its own. that loop, catch the regress without you re-describing the bug each time, is exactly where this goes. being straight: not there today.

@grace_lee26 thank you.., this is exactly pain... the state that looks correct until a second system reacts one is the worst, everything looks green and then some downstream thing double-processes and you hear about it from a customer.

on the report you described thats basically what the receipt already is. after a run it shows what got simulated (the retries, the late and duplicate events), what state changed step by step, and where it broke. the part you really nailed is the last one, which failure is now covered so the agent doesnt reintroduce it later. thats the memory piece and honestly its the thing i care most about too. today the failure goes into the per-api library so its there next time anyone hits that api, but the part where the agent wont reintroduce it in your own repo is still early, being straight about that.

also memory of breakage is a better way to put it than how ive been saying it, might steal that.

@vansh36 ahh good catch man.. thank u.. will fix it

@mirahmlk thanks Miraç, glad the cursor integration felt smooth, that was a big focus for us.

on the replay idea, part of it is there and part isnt, being honest. the sequences today are deterministic so you can rerun the exact same webhook/retry ordering against a change and confirm your handler still behaves the same, thats basically the staging-regression check you're describing. what isnt there yet is capturing a real production sequence and replaying that exact recorded payload ordering against your own staging or prod, right now it runs against our sandbox not your environments. thats a genuinely good ask though, record-from-prod and point the replay at your own env is the thing that turns it from a pre-merge check into a real regression tool. putting it on the list, appreciate you spelling it out...

@tuncaypamurqnk thanks, and honestly thats the whole reason it exists. stubbing webhooks to test retry logic is miserable, you end up writing more mock than real code and it still doesnt behave like prod anyway. glad its clicking for you.

@galdayan this is the sharpest question in the thread, and honestly the one that keeps me up....you're right that a sandbox drifting from the real api is just the same problem moved somewhere else, green here and still breaks in prod. any tool in this space has to answer it or its not worth trusting.

where i can be straight: two things ground it today. one, the failure library isnt guessed from docs, its built from real integration failures, so the patterns actually happened, not ones i imagined. two, nothing counts as verified unless it actually reproduces in a run, so its behavior-grounded not just written down.

what i wont pretend: a fully automated per-api drift monitor that continuously diffs our simulation against the live api isnt there yet. today when stripe changes retry semantics its closer to catch-and-correct than an automated watchdog. thats the honest gap.

and thats exactly the thing that has to exist for this to be trustable at scale. per-api drift detection is on the roadmap and high on it. you're pointing at the real moat and the real risk at the same time.

@cancelkithq this is a genuinely solid setup.... session-scoped idempotency keys on the mutations plus claims-then-deletes-on-failure is exactly what survives a retry storm, most people don't get that far until after they have already been burned once.

and yeah, the reproduce-fix-rerun loop being manual is the exact gap... you clearly already know the pattern, its just painful to do by hand every time and easy to skip under pressure, the whole point is making that part automatic so its not on you to remember.

appreciate you following. if you ever point it at your coupon/pause flows i'd love to hear whether it catches the stuff you already handle or misses something you do, that feedback is worth more to me than any upvote....tbh

@amjad_shaik thanks for the question.... honestly its less that agents expose brand new edge cases and more that they confidently miss the same ones humans do, just faster and at way more volume.

the pattern i keep seeing is the agent nails the common shape, types check, mock passes, looks perfect, then it breaks on the exact edge nobody exercised, retry with the same idempotency key, a payment intent thats requires_capture not actually paid, a session jwt it decodes but never verifies. same edges we always missed, but now the code is generated so its harder to catch in review because it reads so plausible.

so the shift isnt really new bugs, its the same bugs shipping faster and with more confidence. thats basically why this exists, the happy path looking perfect is exactly when i stopped trusting green.

@omri_ben_shoham1 yeah the async/retry layer is where the real bugs live and most sandboxes just skip it entirely.

three scenarios shipped today: delayed delivery, duplicate/redelivery (same event id fired again so you can actually test idempotency), and dropped. covers most of the retry + race surface.

out-of-order specifically: not a dedicated knob yet. variable delays can surface ordering races but a controlled "deliver B before A" isn't in yet. that's the next one i want.

@aadilghani thanks man.. appreciate the kind words

@jasnoor_singh_oberoi yeah idempotency is the one. almost every webhook provider is at-least-once by design, so duplicates aren't bugs on their end, they're just how it works. but handlers get written assuming exactly-once, so the same event fires twice and you get two charges, two users, two emails. doesn't matter what the API does, if there's an async event with a side effect behind it that gap exists. and it passes every test you'd normally write, code is correct, 200 comes back, shape is fine. breaks hours later when the second delivery shows up. by then it's real money or real data. stale state is second most common but idempotency is the truly universal one.

@omri_ben_shoham1  @sabber_ahamed good adjacent question. right now its in between, not binary but not fully variable either. you can set the delay amount so its not just on-time vs late, you can make it 3s or 30s, but its a single fixed delay applied across the run, not per-event jitter where some land at 3s and others at 30s in the same run.

real variable latency, a distribution with tails where some events are way slower than others, isnt there yet. and thats exactly the thing that produces the ordering races and timeout-window bugs, so its tied to @@omri_ben_shoham1  point too. worth having, on the list.

short version, today its configurable but uniform delay, per-event variance is the next step...

@sabber_ahamed good question, and its the right one for CI. isolation is per sandbox, each one has its own state, its own event log, and its own active scenario. so if each run spins up its own sandbox (one call) theyre fully isolated, one jobs retry storm cant bleed into anothers results at all.

honest caveat, a sandbox is a stateful environment, so if two runs deliberately point at the same sandbox id they share state, thats by design not a bug. the pattern for concurrent CI is one sandbox per job, then you get clean isolation even under a retry storm.

short version, own sandbox per run = isolated, shared sandbox = they see each other.

@omri_ben_shoham1 yeah agreed, the duplicate-same-event-id one is the money bug. late is annoying, double-charge or double-grant is the one that actually hurts.

on your question... right now dropped is a clean non-delivery, the event just doesn't land. the nastier case you're describing, connection dies mid-response so the receiver maybe processed it but the sender never got the ack, is not its own scenario yet. the redelivery run covers the downstream outcome of it (you retried and now theres two), but the actual ambiguous-ack failure mode as a first-class thing is not in there. and you are right, retry logic handles those two completely differently, so its worth having as its own knob. putting it on the list.

@thenameisarian yeah, both of those are the right places to poke.

on review vs auto: it's gated, not automatic. a pattern doesn't enter the shared library just because someone hit it once. it only lands after it's reproduced, a buggy handler and a fixed one have to actually diverge in a sandbox run. so the flow is incident → candidate → proof gate → library. the proof gate is what's shipped today. the part that's early is auto-ingestion, pulling a team's live incident into that pipeline without manual curation. that's still more hands-on than i'd like.

on staleness: that's the sharpest version of the question and you're right, it's exactly what breaks a naive shared library. patterns carry applicability conditions, which auth model, which config, which version, so "fixed in v5" is meant to scope the pattern to <v5 rather than warning everyone forever. version-range partitioning is shallow right now. that's the next thing the shared library design has to get right, and "old integrations still tripping on stale patterns" is precisely why.

@rahilpirani Hi Rahil, the hard part with cross-tool memory has always been trust, not recall. When it answers, I want to know which source it pulled from so I can sanity-check before acting on it. Do you surface provenance per answer, or is it more black-box synthesis? In my experience that one distinction decides whether a team actually adopts it.

@rahilpirani It's really nice to see how much the product has changed based on user feedback. Memory is only useful if the system can tell the difference between updated information and conflicting information. How do you know when an old memory is outdated ?

Confirm-step is the right default - I'd rather resolve a conflict than have recency silently win. The one-global-pool part is what I'd pressure-test: if tagging only filters recall, does a draft-vs-canonical conflict from a throwaway experiment still surface while I'm working in an unrelated project, or does tagging also scope where contradictions get raised? Per-project partitioning landing would basically remove that worry.

@vahid_davoudi  Corrections work on two layers. When the graph forms a bad link, you can remove it directly from the Related list (one tap in the web UI) or via the unlink MCP tool. Weak links also get pruned automatically as evidence thins. For the truth vs temporary context question, canonical entries mark what's settled and are protected from silent overwrites. Drafts hold contested context until confirmed.

@thenameisarian  Both surface, but not equally. Canonical memories are protected, so the contradictory Cursor write comes in as a draft for review rather than a silent overwrite. You confirm it supersedes the original or deprecate it. Deprecated memories drop from recall but stay in the audit trail. No tool wins by being last.

@lakshminath_dondeti  The user. Agents are the interface, writing and recalling on your behalf. External sharing is out of v2 scope.

@zcankekozpdmd  Hybrid retrieval (semantic + keyword) handles ambiguity, with graph links as a tiebreaker when signals are close. Stale entries are filtered at the recall layer: deprecated and superseded memories never reach the AI.

@amjad_shaik  Three mechanisms handle this: contradictory writes become drafts for review rather than silently overwriting settled context, canonical memories require explicit confirmation before they're superseded, and deprecated entries drop from recall but stay in the audit trail. Recency alone doesn't win.

@kartikmalik  Yes, two interfaces: MCP tools (remember, recall, search) for AI clients like Claude and Cursor, and a REST API for direct programmatic access. Both are documented in the GitHub repo README.

@phardinghy4670  The recall-by-meaning piece was the hardest to get right. Glad it's landing as actually useful rather than just technically interesting.

@avantigrowthlab  Detection is automatic at write time. When Cursor writes something that conflicts with a canonical from Claude, both surface immediately as a draft-vs-canonical pair with source and timestamp attached. You see the tension the moment it's written. Resolution is yours to call - the system surfaces it, you settle it.

@kyo_shino  Age passes through. Every recalled memory surfaces with its write timestamp and current status. Canonical means a human confirmed it, not that the model should treat it as current truth.

The silent staleness case you're naming is real and not solved in v2. Your patch of stamping every recall with age and treating it as a point-in-time claim is the right direction. Worth building as a first-class feature.

@lennoxbeflying  Ten minutes per session adds up fast across tools. Running on your own Cloudflare free tier at personal scale without hitting limits was a design requirement, not a lucky side effect - glad that part lands.

@omri_ben_shoham1  Building it on your own Cloudflare account was the only architecture where trusting the memory layer isn't a leap of faith. The canonical vs draft decision follows the same logic - if you own the data, you should also own every decision about what overwrites what.

@chielephant  Not a black box. The web UI shows every memory: which tool wrote it, when, and its current status (canonical, draft, or deprecated). You can edit, unlink, or deprecate entries directly. Visibility came before recall in the design, for exactly the reason you named.

@noctis06  Confirm step, not auto-pick. Contradictory writes from any client surface immediately as a draft-vs-canonical pair and you decide which stands. On scope: one global pool per user across all MCP clients. Tagging lets you filter recall by context today; per-project partitioning is on the roadmap.

@markherschberg  Vectorize keeps recall latency flat as memory grows. On silos: v2 doesn't auto-partition yet. You can tag memories by context, but the graph links across domains when memories are semantically close. Automatic partitioning is on the roadmap.

@henry_s_jung  v2 doesn't auto-decay, but every write checks against existing canonical memories. Contradictory new context surfaces immediately as a draft-vs-canonical pair, so stale info gets flagged the moment something newer conflicts with it. The trickier case is memories that were wrong from the start and never contradicted - that's a real gap we're thinking about.

@galdayan  Correcting the root doesn't cascade. The graph shows you what linked off it, so the dependency chain is visible rather than hidden, but walking those downstream nodes is on you. The wrong-from-the-start case is harder than stale-over-time because there's no recency signal to catch it early - that's a real gap we're thinking about.

@podcast_ai  The distinction holds regardless of who writes. Agent writes that conflict with existing canonical memories surface immediately as a draft-vs-canonical pair at write time. Settling a draft to canonical is a human action. Agents write freely but can't settle context unilaterally.

@sabber_ahamed User confirms it. Contradictions surface both writes as canonical vs draft, and you decide which stands. Re-reference frequency is a signal we track, but it doesn't automatically settle anything.

@sabber_ahamed  Theoretical at personal scale. The bottleneck has been hop latency, not CPU. The ceiling becomes real when you layer concurrent multi-hop over conflict reconciliation at multi-tenant scale.

@aryan787544  v2 doesn't decide on its own. Contradictory writes become drafts for your review, not silent overwrites. You confirm what's settled. The boundary stays with you; the system just makes the tension visible.

@birgl1646637  The re-explaining tax is the whole reason this exists. Glad the cross-tool recall is cutting it already.

@fberrez1  Obsidian is notes you write for yourself. This is memory AI tools write automatically across Claude, ChatGPT, and Cursor, recalled by meaning rather than keyword search.

@hongaar Hi Joram, the mailbox-to-tracker gap is where half my support context goes to die. When a customer replies "actually it's still broken" four emails deep, does that thread onto the existing issue or spawn a new one? Curious how you decide what counts as a duplicate versus a genuinely new report, because that call is usually where these tools live or die.

@varunvivek Label or status changes do not trigger updates back to the customer currently, only public comments do. I know other products support this, but I didn't want to make it too 'chatty'. Is this a feature you'd like to see in a product like ServiceBeard?

@galdayan comments on the issue tracker are sent back to the customer through email (delivery through your own SMTP server), unless marked as internal. Thanks for checking out ServiceBeard!

@sabber_ahamed both are supported - this is configurable per Project Rule (so e.g. bug reports can have different behaviour than feature suggestions). Great question!

@tunahan7j2k Interesting edge case. ServiceBeard will create a single conversation and a single issue from this incoming email, it doesn't use CC'd addresses to create additional tickets or links at the moment. How would you expect or want this to work?

@omri_ben_shoham1 Tested some of these scenario's, but not in an as structured way as I'd like. I'm going to to put more (automated) testing towards this. Thanks for raising this!

@thenameisarian ServiceBeard will try its best to keep conversations threaded in both mailbox and issue tracker, and I'm using layered strategies to detect the conversation a message should be part of: by In-Reply-To, then References, then subject+sender. Great question!

@eymen4ufh 

Great questions — two-part answer.

On jargon in specialized fields: The AI doesn't invent terminology — your profile is the source of truth. If you're a compiler engineer, phrases like "LLVM IR" or "loop unrolling" only appear in the tailored resume if you put them in your profile. When targeting a specific JD, the model anchors on the JD's exact wording and selects / rephrases from your existing bullets to bridge the two — it doesn't hallucinate a whole new domain. For academic roles specifically, we treat Publications, Patents, Awards, and Test Scores as first-class profile sections, so citations, PI names, conference venues, etc. get preserved exactly as you enter them.

Two honest caveats worth mentioning: (1) for very niche fields (specific semiconductor process nodes, regulated medical-device terminology, etc.) we recommend a bullet-by-bullet review before submitting — the AI is a strong reorganizer, not a domain expert. (2) Spending 2-3 minutes tweaking one bullet manually the first time usually pays off — the model picks up on your tone for future generations.

On templates: Four built-in templates (Modern, Classic, Minimal, Creative) — all deliberately ATS-parseable: single column, standard section headings, no tables / images / text-boxes. The PDF export is vector (not rasterized), so ATS text extraction is clean.

You can't upload your own template today — that's on the roadmap. What you can do: after generation you get the full editable markdown source — tweak it in the in-app editor, or copy it out into Overleaf / Word / any format your target company expects. A few users generate with us, then paste the content into a Word template their recruiter shared with them. It's a fine bridge until custom templates ship.

Happy to answer follow-ups!

@ceylan1dzf 

Two different problems packed into one question, both worth answering honestly.

Easy Apply specifically: The JD is actually visible on the LinkedIn job page itself — the "Easy Apply" button just triggers the form, it doesn't hide the description. Our Chrome extension scrapes whatever's currently rendered in the DOM. One gotcha: LinkedIn often collapses long JDs with a "See more" link — if the user hasn't expanded that, we only get the truncated version. So the practical advice is click "See more" first, then hit Import. We're looking at auto-expanding it in the next extension update.

Genuinely hidden JDs (some ATS redirects, some career pages that gate the description behind login) are the harder case. There's no scraping around content that isn't in the DOM. For those, the fallback is: paste the JD text directly into Offer Max's /generate page — same output, just skips the auto-scrape step.

Vague / thin JDs (the "seeking a passionate individual to drive impact" variety, all vibes no specifics): the tool doesn't invent detail that isn't there. What it does instead:

• The score-match becomes low-confidence — we surface fewer keyword-match chips, which is itself a signal: "this JD doesn't tell us much."

• The tailored resume falls back to profile-driven writing — pulling from what you did, in your voice, without over-fitting to weak JD signal.

• We have a separate "Research Job" feature that pulls in company / role context to backfill some of what a vague JD leaves out.

Honest limitation: with a truly generic JD, tailoring degrades to "polished but generic" — which is still better than the base resume, but not as sharp as when the JD is specific. In that scenario I'd tell users to spend 30 seconds writing 3-4 bullet points about what they think the role probably wants (e.g. based on the company or team page) and paste that into the JD field. The AI turns manual signal into tailored output remarkably well.

@reda_roqai_chaoui Totally hear you on the "same info 50 times" pain — that's literally the reason the profile-based approach exists. You fill your profile once, we handle the rewrite per JD, and that alone kills most of the fatigue.

On the "everyone sounds the same" concern — the trick is we don't rewrite from a generic template. We rewrite from your actual bullets. If your profile says "Rebuilt Stripe's dispute-handling pipeline to hit 99.97% uptime during a 3× traffic spike", that specific wording, that specific number, that specific voice is what gets tailored. Two candidates targeting the same JD would still produce very different resumes because their profile inputs differ — the AI is selecting and reshaping, not writing from scratch. Generic-AI-voice only shows up when the profile itself is generic (which is a separate problem no tool can fix for you).

Two things help further: the AI is deliberately not templated — no "led X by doing Y resulting in Z%" scaffolding — and we picked Claude Sonnet 4.6 as the writer specifically because it has the best sense of tone across current mid-tier models. GPT-4o-mini would produce noticeably more formulaic output; it's cheaper but the difference in feel is real. Also, if you tweak one bullet manually the first time, the model tends to pick up on your voice for the rest — worth spending 2-3 minutes on your first generation.

@galdayan Fair concern. Based on our research and conversations with people familiar with recruiting platforms, anti-automation systems generally seem to focus on high-volume, unattended application behavior rather than a user saving time on a few repetitive fields. They're not built to catch individual job-seekers using a browser tool to shave 30 seconds off tedious EEO forms. That's why something like Simplify has been around for years, has hundreds of thousands of users, and hasn't been blanket-banned by any major ATS — it's within the norm of "power user tooling", not adversarial behavior.

And honestly, Offer Max does even less than Simplify (we are still catching). Simplify actually tries to fill the whole application — cover letters, custom essay questions, everything. We deliberately don't. Ours is scoped to EEO/demographic and boilerplate contact stuff — the fields that are literally the same across every application you'll ever submit. From an ATS perspective there's just nothing to fingerprint: a radio button click is a radio button click, whether you tap it or the extension does.

So both technically (native events, user's own session, no bulk pattern) and philosophically (individual friction removal, not application farming), we sit comfortably on the safe side of what these detection systems are actually watching for.

@omri_ben_shoham1 This is a topic I’ve spent a lot of time thinking about over the past couple of months — probably more than is healthy for dinner-table conversation.

The main thing we do: the AI is never allowed to invent keywords. Everything in the tailored resume has to trace back to something in your actual profile. So if the JD wants "distributed systems" and you wrote "microservices at Stripe" — we bridge those two phrasings. If you never touched distributed systems, "distributed systems" doesn't magically appear. That's the failure mode you're describing, and it's the exact thing I've been trained (by dinner-table lectures) to prevent.

Add to that: hard word cap per bullet, quantification pressure, and the match-score panel exposes which JD requirements didn't match instead of trying to fake them. If the JD wants a PhD and you don't have one, we say "PhD requirement — not met" instead of writing "PhD-level research experience" 🙃

@aryan787544 You're pointing at the hardest case for any keyword-based scoring — lateral pivots and career jumpers who look weak on paper but crush the interview. Nobody's fully solved this, us included.

A few things we lean on. First, matching is phrase-level, not literal — "microservices at Stripe" registers against a JD asking for "distributed systems" even when the words don't overlap. On top of that, when the model supports thinking mode (Google, Anthropic), we let it reason beyond keyword hits before it commits to a number. And finally the output isn't just the score — there's a "strategy" section next to it that surfaces transferable strengths the number alone can't capture.

But honestly the score is meant as signal, not verdict — we don't gate applications on it. A 40/100 with strategy notes saying "your payments experience translates directly to this fintech role, lead with the $4B/month figure" is often way more actionable than a 90/100 for a role you're overqualified for. Great candidates just have to trust the strategy more than the number.

Thanks for the 🚀 — this is exactly the question I wish more people asked about scoring systems.

@omri_ben_shoham1 the audience reaction carries over - and you can choose to mute in two levels. You can mute everyone, or mute everyone who isnt your friend / companion - so you can decide if you want to watch the movie with everyone (i love watching horror movies or comedies this way), but if you want it to be with friends and just hear them, you can mute everyone else.

@berkehallokdww So while you are watching - you don't see faces or avatars. You only see glows of other people in the room - the empty theatre environments always made it a bit depressing for me. And you have two ambient audio modes - listen to everyone, or listen to only friends. So if you click on listen to friends only mode, you wont hear any of the others, so its almost like being in a private room with friends - or even on a date.

@roopesh_donde The display does set the experience though. Even on a 2, the display is okay. What sort of headset do you have?

Mobile devices would take away the whole theaterical experience thing right? If you have a Quest 2 or Quest 3 device, you can check it out and play some of the trailers to see what it feels like.

@ethanyoungl8 Yes! We've tested Flowing with libraries of 5,000+ PDFs (in the chemistry field), and that's actually quite close to the scale we designed it for.

Both automatic keyword detection—which surfaces relevant snippets as you write—and manual keyword search continue to work well even with libraries of that size.

@callmericky Thank you so much—it really means a lot coming from someone who built Paperly with me.

Looking back, I think Flowing actually grew out of the same question we were asking back then: how can researchers spend less time searching for information and more time thinking and writing?

This time the focus shifted from reading to writing, but the goal is still the same—helping researchers make better use of the knowledge they've already collected.

Thanks again for all the support over the years! 😊

@luzunefe16087 Thanks! I really like this idea.

Our current goal is to make it much easier to find the right evidence while you're writing. But as you pointed out, retrieving a relevant paper is only part of the problem—it's equally important to know whether the evidence actually supports the point you're making.

A workflow that helps researchers spot mismatches between their draft and the cited evidence would be incredibly valuable. We'll definitely keep exploring ideas along these lines.

Thanks for the thoughtful feedback!

@lee_jay1 Good question. Actually not yet. At the moment, Flowing focuses on the text content of your PDFs rather than handwritten notes or annotations. It's definitely an interesting direction, though, especially for researchers who annotate papers extensively. Thanks for the suggestion!

@roopesh_donde I'm really glad it resonates with your experience. 😊

At the moment, Flowing is primarily designed for individual researchers, so real-time collaboration isn't supported yet. It's definitely something we've heard interest in, though.

Yes, you can absolutely work on multiple projects. You can create separate documents and switch between different paper libraries depending on what you're writing.

Right now, our main focus is helping researchers stay grounded in their own literature while writing. Once that workflow is solid, we'll continue exploring features that make research collaboration easier as well.

Thanks again for the thoughtful questions!

@hambali_salisu Not a direct Zotero/Mendeley plugin today — Flowing is built for the writing loop, not bibliography management.

Most people use both: Zotero/Mendeley for citations, Flowing for drafting with PDF snippets you can verify.

@pablo_ani We’re tracking this now (accept / edit-then-keep / dismiss vs typing on your own), but it’s still too early for a reliable %.

In practice it’s rarely all-or-nothing: most useful cases look like draft → check evidence → light edit → keep. “Start from scratch” usually means the suggestion didn’t fit that spot in the manuscript, not that people avoid AI entirely.

Happy to share more once the data is actually meaningful.

@dev_tanna Congrats on the launch — tying Stripe revenue back to the channel that actually earned it is the analytics everyone should've built; "which channel actually pays" beats another vanity-traffic dashboard. You shipped without a demo, so I made you one: a looping GIF of Mochi actually working — free, white-label, no strings.

How to use it: download it and drop it into your Product Hunt gallery, right after your screenshots — a moving shot of the product in use, next to static images, makes the page land harder and holds attention longer. Works pinned in a comment or on your site too.

Built it with FoxPlug — paste your site and it turns what you shipped into launch videos, GIFs and posts. This one's on us; your kit + make your own: foxplug.com/g/7f346213cebb47e7b9de

@baliy Hi there, we started checking this by hand a few months back and what surprised me was how differently each model described us, and how fast it drifted after one blog post got indexed. Do you track the delta over time so you can tie a shift in what the models say back to something specific you published? The one-off snapshot is interesting, but the trend is what would actually change how we write.

@henry_s_jung Thanks. And yeah, you already know the punchline then, they disagree way more than people expect.

On how often: for the plain "does it mention us" they're fairly consistent, but the moment you look at who gets named alongside you, the three often return pretty different sets. For big established brands they mostly line up; for smaller or newer ones the overlap can be surprisingly small, sometimes only one name in common across all three. That's exactly why I show them per-assistant instead of blending into one number, an average would hide that you might be strong on Gemini and invisible on ChatGPT.

On timing: each check is point-in-time, a snapshot. Your checks are saved though, so you re-scan (monthly works well) and watch the answers drift. It's a manual re-scan today, not automatic weekly tracking, that's the direction, but I didn't want to fake continuous monitoring before it's solid.

@omri_ben_shoham1 Yeah, that "who wins instead, and why" gap is the whole reason I built past just a yes/no mention.

It does more than flag them. For each answer you see the sources the model leaned on, so when a competitor keeps getting named you can usually see why: they're sitting on the pages the model trusts, a Reddit thread, a listicle, a review roundup, or a page structured cleanly enough for the model to quote. Nine times out of ten "why do they keep winning" comes down to being present on those trusted sources and being easy to parse, and the citations make that visible.

What it won't do is read the model's mind and hand you one definitive reason, no tool honestly can. But seeing who's cited instead of you, on which prompts, from which domains, gets you most of the way to "right, that's the thread I'm not in, the roundup I'm missing from", which is usually the real lever.

@aryan787544 Thanks, that competitive-landscape angle is exactly the framing I care about, glad it lands.

On noise vs a real shift: honestly you can't tell from one check. A single run wobbles within a band, so if something moves on one prompt one time, I treat it as noise. What I trust is a move that shows up across the whole cluster of prompts, holds on the next scan, and ideally shows on more than one assistant at once. That pattern is usually real, and it almost always has a cause you can point to, a page that got indexed, a competitor's push, or a model update.

So the rule I'd give a founder is simple: don't react to any single number, react to a direction that repeats. That's the whole reason the tool leans on monthly re-scans and trends instead of one snapshot, and it's the part I most want to sharpen, only surfacing moves big and sustained enough to actually mean something, not every fluctuation.

@seherkrmacmvsb Thanks, that's exactly the gap that always bugged me. Your own score in a vacuum doesn't really tell you anything, "am I winning or losing" only means something against who's actually showing up for those prompts. Glad the leaderboard framing clicks for you too.

@arin1841226 Thanks, really glad it landed that way. The "not a vanity score" bit is exactly what I was going for, a number on its own is useless, the leaderboard is where the actual "so what do I do about it" lives. And yeah, small brands are where the models diverge most, there's less out there for them to agree on, so each one fills the gaps its own way. Appreciate you running it on real brands.

@galdayan Exactly, one call tells you nothing, so we don't score off a single request. We run prompts in clusters and show the average per topic cluster, which smooths out most of the single-draw randomness.

Even then the data still moves around, so where we can we also run from geolocations close to the project's main target audience, since answers shift by region too.

It's still not perfectly precise, especially for newer brands where there isn't much out there for the models to go on. But it gives you a usable ballpark, and re-scanning once a month is where the real signal is, you watch the trend instead of chasing one number.

@amjad_shaik Yeah, all the time. Models will state old pricing, an old tagline, even the wrong founder, with full confidence.

Rough way I split it: if a model names you but cites no real source, that's usually its memory talking, and where hallucinations creep in. If it cites a page but the page is stale, that's outdated public data. And if it never mentions you at all, that's just a gap, not a wrong answer.

So the tool shows what each model says next to the sources it leans on, and you judge from there. It won't certify what's true, but seeing the claim beside its source usually makes it clear which of the three you've got. Honestly the "confidently wrong" case is the scariest, since publishing more doesn't fix it, you have to go correct the sources it trusts.

@atlkulac3065 Thanks, that's really the whole bet. A score tells you you're losing but not what to touch; the sources are the part you can actually act on, get into that roundup, fix that page, earn that mention. Means a lot that it reads as actionable and not just another dashboard. Appreciate you taking the time to dig in.

@spiri7 Thanks, this really means a lot. Glad it's already sparking content ideas.

On the features:

• Email alerts when a report's ready or your visibility moves a lot - yeah, I want that too.

• "Content opportunities" from prompts where competitors show up and you don't - the gap view kind of does this already, and turning it into actual topic suggestions is an easy next step.

• A list of guest-post blogs - bit further out, but I like the idea. Which ones matter in your space?

Really helpful, thanks for taking the time to write all this.

@omri_ben_shoham1 I agree, friction has been found to wear off after awhile and people will bypass anyways. However, I think that a large portion of people do just need a little bit of nudge to stay locked in, so hopefully this keeps developing with a community behind it to really make it impactful! The flow of how it works is pretty creative and removes a lot of the mental workload off of the user.

@said_aitmbarek Thanks!

@cerenekeryxdpj it is!

@kiog_aser Thank you SO MUCH for the support! Always happy to hear what users are thinking 🥰

@smail1452579 have you tried it?

@sleymantalnkyt once a book is generated, we allow for 10 image re-generations which can cover broad changes or minute details to really make the story yours!

@sleymantalnkyt you can regenerate the entire image or have a character change expression etc. our customers love the ability to edit and get it just right!

@mcahit321044 can you share the title? I don’t see in the backend something matching your description so want to double check. Thanks

@yldz1742642 we have character consistency and outfit changes happen mostly if the story requires. I looked through the backend and don’t see a story where each image is different outfit but feel free to share specifics that I can look into! Thanks

@ethem_topr36430 that’s exactly what we have solved for! Our characters are consistent along with scene and style. Sometimes AI does hallucinate , but you can regenerate the image and it fixes the issue. Give it a try! Thanks

@ethem_topr36430 our stories should definitely have character and image consistency. Please feel free to upload an image and I can help you with anything you might be seeing!

@ethem_topr36430 our stories should definitely have character and image consistency. Please feel free to upload an image and I can help you with anything you might be seeing!

@niteshseram Congrats on the launch — dynamic, per-page Open Graph images is something every product needs and almost nobody does well; "design it once, every page gets a share image that converts" nails it. You shipped without a demo, so I made you one: a looping GIF of OGCanvas actually working — free, white-label, no strings.

How to use it: download it and drop it into your Product Hunt gallery, right after your screenshots — a moving shot next to static images makes the page land harder and holds attention longer. Works pinned in a comment or on your site too.

Built it with FoxPlug — paste your site and it turns what you shipped into launch videos, GIFs and posts. This one's on us; your kit + make your own: foxplug.com/g/c679a3ea59154f0a95c5

@rza1192250 Thanks for checking out

@stevenleep Congrats on the launch — independent governance to keep commercial software reliable for the long run is a real, unglamorous problem nobody owns; "launched then abandoned" is exactly the gap. You shipped without a demo, so I made you one: a looping GIF of it actually working — free, white-label, no strings.

How to use it: download it from the page we made you (below) and drop it into your Product Hunt gallery, right after your screenshots — a moving shot next to static images makes the page land harder and holds attention longer. Works pinned in a comment or on your site too.

Built it with FoxPlug — paste your site and it turns what you shipped into launch videos, GIFs and posts. This one's on us; your kit + make your own: foxplug.com/g/ca0642ecb2d84743977d

@amjad_shaik 

This is a service we offer rather than a specific product.

If you're looking for a product-based solution, please feel free to check the following reference, which may better meet your needs:

https://github.com/scanaislop/aislop

@amjad_shaik 
Yes, this is becoming increasingly important.

Since we provide a human-driven governance service, we do help teams identify and address reliability risks introduced by AI-assisted development. Our experts review the codebase to catch subtle issues that automated tools often miss — such as logical inconsistencies, architectural weaknesses, maintainability problems, security risks, and long-term technical debt.

We focus on combining human judgment with structured processes to ensure AI-generated or non-R&D code remains reliable and sustainable over years, not just at launch.

Happy to share more concrete examples if you're dealing with this challenge.

@halimezcalvran 
Thank you for your thoughtful feedback — I really appreciate it!

We launched this service specifically to help teams solve the long-term governance challenges of AI-native applications and products built by non-R&D members. Your point about transparency and sustained investment is exactly why we exist — to provide reliable, ongoing support that builds lasting trust.

We’ll take your suggestion regarding a public changelog and roadmap seriously as we continue to develop the service.

If you’d like,
I’d be happy to share more details about how we can support your team’s specific needs.

@aakash_mishra7 Congrats on the launch — cutting through the AI-tool noise to match people to what actually fits their use case, "not the hype," is a needed antidote right now. You shipped without a demo, so I made you one: a looping GIF of YourOnlyAI actually working — free, white-label, no strings.

How to use it: download it from the page we made you (below) and drop it into your Product Hunt gallery, right after your screenshots — a moving shot next to static images makes the page land harder and holds attention longer. Works pinned in a comment or on your site too.

Built it with FoxPlug — paste your site and it turns what you shipped into launch videos, GIFs and posts. This one's on us; your kit + make your own: foxplug.com/g/58d37692ed32467fbc22

@henry_s_jung it has its own benchmarking system which allows recommending the perfect tool according to the query of the user.

@_syed_zubair_ahmed Congrats on the launch — members, check-in, payments and a finance forecast all in one place is what most gym owners are duct-taping together today; the dashboard looks genuinely calm. You shipped without a demo, so I made you one: a looping GIF of Gymsly actually working — free, white-label, no strings.
How to use it: download it and drop it into your Product Hunt gallery, right after your screenshots — a moving shot next to static images makes the page land harder and holds attention longer. Works pinned in a comment or on your site too.

Built it with FoxPlug — paste your site and it turns what you shipped into launch videos, GIFs and posts. This one's on us; your kit + make your own:

foxplug.com/g/755fea42622741c08150

@saadetcihaa03j Good question, and worth being upfront about: Glimpse works from the audio/transcript, so it's strongest on talk-heavy videos — podcasts, lectures, tutorials where the speaker narrates what they're doing. In practice most code walkthroughs do narrate as they type, so summaries still capture the flow and key decisions. But for silent screencasts or demos where the screen carries info that's never spoken, some of that gets missed today.

@araszengin54995 You can currently favourite infographics and view them in the favourites section on the home page. Working on a way to organise them into folders.

@pathfinderen Congrats on the launch — treating talent as a position on real axes, scored against actual paths, "a snapshot, not a label," is a genuinely different take on the assessment space, and "no account to run it" is a great touch. You shipped without a demo, so I made you one: a looping GIF of Orivon actually working — free, white-label, no strings.

How to use it: download it from the page we made you (below) and drop it into your Product Hunt gallery, right after your screenshots — a moving shot next to static images makes the page land harder and holds attention longer. Works pinned in a comment or on your site too.

Built it with FoxPlug — paste your site and it turns what you shipped into launch videos, GIFs and posts. This one's on us; your kit + make your own: foxplug.com/g/fa304b1f0d394eb68287

@aryan787544 Thanks, I'd really appreciate that.

You can reach me at orivon.support@gmail.com

Looking forward to hearing your thoughts. (I can't post link on IH)

@emin6zgn Thanks a lot! That's actually one of the main goals of Orivon. I wanted it to feel less like a personality label and more like a practical snapshot of how someone naturally creates value. Really appreciate you taking the time to try it.

@henry_s_jung Your decisions are your data. Dcyde won't run AI over them itself, nothing reads or summarizes them in the background. A person makes the call and it stays on the record with their name.

If you want to connect your own AI to read them, that's up to you. I want to add an API for that, and for exporting your decisions wherever you want. It's in the backlog for now.

@celalasravxqhf  Keyword-based plus filters, no AI. You search across the decision and its reasoning, not just the title, and narrow by scope, author, or date range. No AI reading or interpreting your decisions, that's a deliberate line.

@galdayan My bet is that passive AI capture just makes noise. It logs everything, so no one trusts the list. A person choosing to pin is what makes it matter. The teams who lose decisions the worst usually aren't AI-savvy at all, the whole auto-detect-from-chat race assumes everyone already lives in AI, and most organizations don't.

That's why /pin lives inside Slack, you don't leave the channel, and I want to add more connectors so you can capture wherever your team already works. Whether the habit sticks, I'll only learn from real use.

@keremdbga Exactly, the DM graveyard is the enemy. And the "why" is just the start: on each decision you can tag specific people, add scopes to keep things organized, set an owner who's accountable for the call, and ask the team to align through a private vote. That last part has worked surprisingly well for remote teams, you get honest signal instead of meetings. Is your team mostly remote? That's exactly who I built the alignment feature for.

@robersonbr32549 Hi. It's actually a feature in the backlog; I am glad you shared this. Out of curiosity, when you look back months later, is it usually one decision you're hunting for, or the whole chain that led somewhere?

@filizaltuniu43 Yes, the search has a date range filter. You can filter by scope (like "Design System" or "Pricing"), by author, and by date range, and there's keyword search across the decision and its reasoning on top