Intent by Augment Code. Is spec-driven multi-agent development the next step after the IDE?
Augment Code has been quietly building enterprise-grade coding tools for large engineering teams, and they launched Intent. Тheir answer to what comes after the IDE.
According to their announcement:
What makes Intent different is the living spec model. Requirements update automatically as agents complete work, so every agent shares the same state. No drift. No "which version are we working from?" A coordinator breaks your prompt into tasks, delegates across specialist agents running in parallel across isolated worktrees, and hands you a clean PR at the end.
In a recent Product Hunt thread on agentic coding setups, most developers were still stitching together Claude Code + Cursor manually and managing context across terminal panes themselves. Intent seems to be a direct architectural answer to that problem.
Worth noting: The New Stack recently covered how Cursor, Claude Code, and Codex are forming composable layers rather than one winner. Intent fits that picture. It's BYOA (bring your own agent), so you can use your existing Claude Code or Codex subscription inside it.
Curious whether the coordinator-delegate approach holds up on real production codebases. Has anyone tested it yet?
Replies
Does this really save time or just add more layers
@isaac_dominic1 Intent is built for (multi-step, multi-file changes with multiple agents), it saves time by removing layers you’re currently managing yourself.
Instead of you tracking which agent did what, which spec is current, and which branch has which diff, Intent gives you a single workspace where:
a coordinator turns your prompt into a spec and breaks it into tasks you approve,
specialist agents run in parallel from a shared living spec (no drift, no stale prompts),
and a verifier checks the work against the spec before you get a PR.
For tiny one-line fixes, a single-agent development mode (without orchestrator) is still possible, Intent orchestrator mode pays off when you’d otherwise be babysitting multiple agents and branches by hand. If you have more questions let me know!
@jaysym Makes sense, sounds like it saves time once things get complex not for small tasks
this feels like a natural shift to me. I have already noticed that writing code is no longer the hardest part, it is keeping everything aligned across tools and agents.
@rakesh_gupta20 You are totally right about it! This is why we have built Intent. Thanks for the comment!
How easy is it to set up in the beginning?
@daisy_morgan2 It’s pretty quick to get to “first agent message.” Most people download the app, pick a provider (Auggie, Claude Code, Codex, etc.), and are sending their first agent request within a few minutes, our funnel data shows the median time from completing setup to creating a first workspace is about 1–2 minutes.
@jaysym That's fast, makes the onboarding feel really smooth
Not sure if it is the same thing but Claude does have an orchestrator that does the same thing. I used the orchestrator assign the agents their duties and the agents report back their progress. The orchestrator will then compare to my master document to the agents assignment for e2e testing and verification.
@david_sherer Totally, Claude’s orchestrator is close in spirit, and Intent is designed to sit on top of setups like that rather than replace them.
The main differences are:
Workspace + git, not just chat threads: Intent ties the orchestrator into isolated git worktrees, diffs, terminal, and PRs in one place, so each “spec + agents” run is a real, reviewable workspace, not just a conversation.
Living spec is the first-class surface: the spec isn’t buried in a chat, it’s a persistent document that every agent reads from and writes back to as they work, so it becomes the actual source of truth for the code changes over time.
BYOA coordination layer: you can still use Claude Code (or Codex, etc.) as the underlying agents, but Intent gives you a single orchestration and review layer across them, instead of rebuilding that logic per tool.
So if you already like Claude’s orchestrator, Intent is basically a way to plug that into a spec-driven, git-aware workspace rather than managing everything across separate chats and branches.
It's also easier to set up, we have done the heavy lifting of the setup for our users.
@jaysym Thank you for that clarification!
The living spec idea is what stands out to me, most multi-agent setups break down when agents lose track of shared context. What I'd want to know is how it handles two agents editing the same file at the same time.
@farrukh_butt1 Great question : Intent workspaces are backed by isolated git worktrees, so each agent (or human) typically edits its own clean copy of the repo rather than literally sharing a single mutable buffer. This avoids most low-level file conflicts and lets multiple agents work in parallel safely over multiple branch.
When two agents do touch the same file, Intent relies on git-level diffs and merges rather than last-writer-wins edits, so conflicts surface as standard merge conflicts you can review/resolve in the workspace UI (and via your normal PR flow) instead of silent overwrites.
Is the learning curve steep here?
@bella_christine Intent is designed as a familiar developer workspace that feels like “what comes after the IDE” so developers mostly reuse their existing git + PR habits rather than learn a whole new mental model.
What people need to learn is how to work within this new concept: training their mind to handle multiple PRs across multiple branches at the same time. The tool is designed to help manage several tasks simultaneously, but it does come with a learning curve. Once you get used to this way of working, I bet that you won’t want to go back. If that’s not the case, I would be happy to discuss why with you, as this will help us improve it.
specs are just docs that lie slower. the real bottleneck with multiple agents isnt coordination its conflict resolution when two of them disagree on approach. a living spec doesnt fix that, it just makes the disagreement harder to notice until the PR is already broken
@umairnadeem this is so true. It makes a lot of sence. BTW today we're launching Intent on Product Hunt so your feedback and support will be highly appreciated.
@umairnadeem Totally fair take, a bad spec just lies more slowly when used alone.
In Intent, the “spec” is less a frozen doc and more an execution log: agents update it as they work, and their changes are grouped by task in isolated worktrees, so when two agents disagree you see the divergence per-task before anything hits rather than in one giant broken PR.
On top of that, a verifier agent explicitly checks “spec vs reality” and flags inconsistencies before your team validate the PR and do a merge, which is aimed directly at the “hidden disagreement” problem you’re describing.
Please let us know if you try it and share your experience with our tool. We would be happy to discuss it further.
The interesting shift is that code generation is no longer the only bottleneck.
Once multiple agents are involved, the harder problem becomes state alignment, task ownership, and reviewability. A living spec only matters if it also reduces ambiguity at handoff points.
@luca_ardito Right, and that’s exactly the role of Intent’s reviewer agents: after each change, Intent can run a reviewer agent whose sole job is to detect divergence between the living spec and the code, instead of relying on the original builder agents to self-correct.
In other words, multi-agent work will drift: Intent’s answer is to make that drift visible and fixable by dedicated reviewer agents that run on every modification, so state alignment becomes an explicit, automated step in the loop rather than a hidden problem.
Hello Aria
Spec-driven, multi-agent development is a fascinating direction. What strikes me most is the shift from "tell the agent what to do" to "give the agent intent and let it plan" — that's actually closer to how human teams work.
We're navigating a version of this in a totally different domain with Hello Aria, our AI personal assistant (WhatsApp/Telegram/iOS). Users don’t give Aria a step-by-step workflow — they express intent (“remind me about X”, “block time for this”) and Aria figures out the execution. The overlap with what Intent is doing at the code layer is striking.
Curious if Augment Code is thinking about how Intent handles conflicting agent decisions — like when two agents have different specs for the same component?