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
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!
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!
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
Scarlett.
@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?