Five days. No weekends. One relentless experiment. I gave Augment Code’s Intent — the most ambitious multi-agent coding orchestration platform available today — everything I had. I used it to build Lumina Pro, my enterprise-grade evolution of the Lumina AI platform, from the ground up. What emerged from that marathon was not just a product. It was a front-row view into what the future of software development actually looks like — in all its extraordinary, messy, addictive, occasionally chaotic glory.
This is not a press release. It is a practitioner’s honest account. I will tell you what astonished me, what frustrated me, what I would do differently, and why — despite everything — I believe Intent represents the next genuine evolutionary step in how human beings build software.
The Arc That Got Us Here
To understand why Intent matters, you need to understand the arc of the last two years. It moves in three distinct chapters.
Chapter one: the IDE era. We added AI autocomplete to our coding environments. GitHub Copilot, Cursor, Augment Code, early Cline — tools that sat beside a human developer and suggested the next line of code. Useful. Impressive. But fundamentally still in the service of the human typing.
Chapter two: the CLI agent era. Claude Code, Auggie, Codex in agentic mode, early terminal-native agents. You could now hand a task to an AI agent and walk away while it worked. This was qualitatively different. The agent was no longer finishing your sentences; it was starting its own paragraphs.
Chapter three, which we are now entering, is the orchestration era. This is where one AI coordinates many. Where you describe a goal and a hierarchy of agents figures out how to decompose, assign, execute, and verify the work. Andrej Karpathy, who coined the term ‘vibe coding’ in early 2025, declared it passé within twelve months, writing that ‘the new default is that you are not writing the code directly 99% of the time, you are orchestrating agents who do, and acting as oversight.’ He proposed a replacement: agentic engineering.
“The scarce resource has shifted. It is no longer implementation skill. It is architectural judgment, problem decomposition, and orchestration discipline.”
Google understood this early. Their Antigravity platform — a VS Code fork with an explicit Manager Surface — gives developers a dashboard to manually spawn and monitor multiple parallel agents across workspaces. It is powerful. The human remains the orchestrator, directing the fleet.
Augment Code’s Intent takes a different philosophical bet. It asks: what if the AI is the orchestrator?
What Intent Actually Is
Intent is a standalone macOS desktop application. Not a plugin. Not a terminal extension. A purpose-built environment for what Augment calls ‘augmented development’ — a new category that sits above the IDE in the same way that the IDE once sat above the text editor.
The architecture centres on the number of agent types working in a coordinated hierarchy. A Coordinator agent reads the codebase through Augment’s Context Engine, drafts a Living Spec — a structured document describing what needs to be built — and breaks the work into discrete tasks. Implementor agents, which can run in parallel, each execute a task in an isolated git worktree. A Verifier agent checks results against the spec before surfacing them to the developer.
This is meaningfully different from anything that came before it. In Claude Code’s multi-agent setup, you are essentially running multiple Claude sessions yourself, manually coordinating what each one works on. In Google’s Antigravity, you spin up agents from a dashboard. In Intent, you describe what you want, and a coordinator agent decides how to build it.
If IDE stands for Integrated Development Environment, Intent is something new and could be refered as an ADE, Augmented Development Environment. The integration is not between the developer and the code. It is between the developer’s intent and an intelligent system that translates that intent into coordinated action.
Augment’s technical foundation here is not trivial. Their Context Engine processes over 400,000 files through semantic dependency graph analysis. In independent benchmarks using the same underlying model — Opus 4.5, running identically across Claude Code, Cursor, and Augment — the Context Engine alone produced solutions to 17 more problems on SWE-bench Pro than Claude Code and 15 more than Cursor. Same weights. Same training. Different architecture.
Five Days in the Deep End: Building Lumina Pro
I did not use Intent for a toy project. I used it to build Lumina Pro — the enterprise evolution of my Lumina AI platform, which allows anyone to deploy AI-powered knowledge assistants on their websites. Lumina Pro takes this several steps further: enterprise-grade architecture, multi-tenant infrastructure, production deployments, the works. It is not a small project. I had been putting it off. Intent was, honestly, the reason I finally started.
For the first several sessions, I worked with a single main coordinator. I described the project. The coordinator read the codebase, wrote a spec, and began delegating. As the screenshot from my actual session shows, the coordinator eventually delegated to 177 agents. That number is not a typo.
The experience of watching 177 tasks assigned, tracked, and executed — while I focused on architectural decisions rather than implementation — is genuinely difficult to describe to anyone who has not sat inside it. The closest analogy is being the technical director on a construction project large enough that you need a foreman. Except the foreman never sleeps, never complains, and reads every line of your documentation before giving a single instruction to a worker.
The progress I made in five days would have taken my previous workflow weeks. That is not an exaggeration. This is real. Intent works.
“Watching 177 tasks assigned, tracked, and executed while I focused on architecture — the closest analogy is being a technical director with a foreman who never sleeps.”
But I also ran multiple coordinator agents simultaneously. And this is where things got interesting.
When You Run Multiple Coordinators: The Honest Account
I started running additional coordinators for two reasons. First, honesty: impatience. Intent currently uses GPT-5.4 for coding tasks — a powerful model that reads carefully and reasons deeply before proposing solutions. That carefulness takes time. While one coordinator’s wave of tasks is processing, a founder’s instinct is to push forward on another front. So I started a second coordinator. Then a third. At peak, I had multiple coordinators running, one of which had delegated work to close to 100 agents. Another had 12. A third, nearly 100.
The second reason was more structural. On large stacks, a single coordinator’s conversation thread eventually becomes very long. Intent’s interface is smooth, but long threads introduce noticeable lag — a familiar challenge that Augment also addressed in the IDE version of their tool in Q4 of last year. The engineering team is aware. It is coming. But today, in public beta, it is real.
What happens when multiple coordinators run simultaneously without explicit inter-coordinator communication? Exactly what you would expect if you hired two foremen and forgot to tell them to talk to each other.
• Commit messages from different coordinators clashed and overlapped
• Deployment targets got confused — one set of worker agents briefly attempted to deploy to the wrong production project entirely (my guardrails caught it, but it happened)
• Context about architectural decisions made by one coordinator did not automatically propagate to another
• Worker agents spun up by a new coordinator occasionally lacked the full project context held by the original, requiring manual onboarding
This is not a catastrophic failure mode. Every problem was recoverable. But it requires the orchestrator — you — to actively manage the coordinators the way a senior executive manages multiple project leads. You need check-ins. You need to remind them of shared constraints. You need to watch GitHub like a hawk for conflicting commits.
Amelia Wattenberger, Intent’s lead product designer, addressed this exact pattern in a discussion thread I encountered while researching this article. Her advice: keep workspaces PR-sized, store context in notes rather than in the agent chat thread itself, and — critically — remember that agents can read from other workspaces, so a knowledge base workspace can serve as a shared reference for multiple coordinators. These are the right instincts. The tooling around them is still being built.
What Everyone Who Has Tried This Is Learning
My experience is not unique. The practitioner community is working through identical challenges at scale. Zen van Riel described it directly: ‘Spin up five instances, point them at your project, and watch your codebase grow at five times the speed. The reality is far messier. Every agent tries to edit the same files, merge conflicts pile up, and suddenly you are spending more time untangling code than you would have spent writing it.’ Cursor’s own engineering team found that equal-status agents using file locking held locks too long, and 20 agents produced the throughput of two or three. Their solution: three distinct roles — Planners, Workers, and Judges — a hierarchy that Intent’s coordinator model is already implementing.
Claude Code’s Boris Cherny, the tool’s creator, revealed his personal workflow: running five Claude sessions in parallel, numbered tabs on a terminal, shipping 20 to 30 pull requests per day. Human-as-orchestrator, manually managed. It works, but it demands constant attention.
Intent’s bet is that the coordinator AI should manage this complexity so you do not have to. For small to medium stacks and single-coordinator workflows, that bet pays off immediately and dramatically. For large, complex, multi-front projects like Lumina Pro, the best practice is still emerging.
“Context engineering is the skill that does not disappear. Every coordinator agent I ran needed exactly what every AI tool needs: a clear, structured picture of the world it is operating in.”
One pattern from Google’s parallel approach is worth noting: their Antigravity platform gives developers an explicit Manager Surface — a dashboard where you decide which agents to spin up, what each one does, and how they relate to each other. You are the orchestrator. Intent gives this role to the AI coordinator. Neither philosophy has won. But Intent’s approach produces dramatically higher throughput in the right conditions.
Context Engineering Does Not Disappear
If there is one insight I want every reader to take from this article, it is this: the skill of context engineering does not diminish in an orchestrated multi-agent world. It becomes more important.
Every coordinator agent I ran — whether it was the primary with 177 delegated tasks or a secondary spinning up 12 workers — needed exactly what every AI tool has always needed: a clear, structured, accurate picture of the world it is operating in. Project documentation. Architectural decisions. Constraints. Prior choices. The history of what has been built and why.
The difference in an orchestrated system is that context failures propagate. A misunderstanding at the coordinator level cascades into every worker agent it instructs. A worker agent that lacks context about a previously established architectural pattern creates technical debt at scale. This is what the Intent team’s emerging best practice around ‘notes’ — persisted, structured context stored outside the conversation thread — is designed to prevent.
The developer who thrives in this environment is not the one who writes the most code. It is the one who maintains the clearest, most accurate shared context — the one who, as Augment’s Amelia Wattenberger put it, keeps the coordinator’s notes current so every agent in the fleet knows what every other agent knows.
The Cost Reality
I will be direct about cost, because too few practitioners are.
On days of full agent spread — multiple coordinators, waves of parallel workers, frontier models processing complex codebases — I consumed approximately 100,000 Augment credits per day. Augment’s Max plan for teams runs at approximately $200 per developer per month and provides around 450,000 credits. At that consumption rate, a single heavy development day uses nearly a quarter of a month’s allocation.
The math depends entirely on what you are building and which LLMs you are using. If you are building a production platform for commercial deployment, the cost comparison shifts dramatically: against the cost of engineering salaries, even sustained heavy usage is remarkably economical. If you are experimenting — as I partly was — the economics are different. Intent is not a casual tool for weekend hobby projects. It is a serious development environment that rewards commercial context.
For those who want to stretch further, Intent also supports external models, including OpenAI’s Codex API, which has its own $200/month plan. You can also enable the OpenCode coding agent in Intent, and if you are running a strong computer, you can run local LLMs to power it. I did not test this combination, but it may offer meaningful additional capacity for heavy users.
The broader cost context across the AI coding industry is sobering. A Syntax.ai analysis found that GitHub Copilot’s $19/user/month licence carries a true first-year cost roughly six times higher when implementation and overhead are included. The industry underprices its tools and overprices the actual cost of deploying them at production scale. Intent’s credit system is more transparent than most.
What Intent Is Not
Intent is not for building websites. It is not a Bolt.new, Lovable or a v0. Those tools excel at rapid, visually focused prototyping of relatively simple applications. Intent is built for complex, evolving, production-grade software projects where codebase depth matters and architectural coherence over time is the actual challenge.
Intent is also not yet fully autonomous. You need to be present. You need to monitor coordinator progress, review wave completions, catch the occasional misfired deployment target, and step in when coordinators diverge. The tool dramatically reduces the implementation burden. It does not eliminate the architectural judgment burden. That remains yours.
And Intent is currently macOS-only, in public beta. Rough edges exist. The long-context lag on extended coordinator threads is real. Inter-coordinator communication requires manual discipline today. These are solvable engineering problems, and Augment’s track record — they fixed analogous issues in the IDE tool within months — suggests they will be solved.
Practical Guidance for Anyone Considering This
If you are ready to experiment with Intent, here is what my five days taught me:
• Start with one coordinator. Resist the temptation to spin up multiple coordinators early. The single-coordinator model is where Intent shines most clearly, and understanding it deeply before adding complexity is worth the patience.
• Keep workspaces PR-sized. The Intent team’s guidance to size workspaces around the scale of a pull request is hard-won. Smaller, well-scoped work units produce cleaner delegations and cleaner results.
• Treat your notes as infrastructure. Store architectural decisions, constraints, and context in coordinator notes. (spec) — not just in the conversation thread. This is your shared memory across the agent hierarchy.
• Monitor GitHub actively. On multi-coordinator setups, watch your commit history in real time. Diverging coordinators produce diverging commits, and catching this early is far less painful than untangling it later.
• Put guardrails on production deployments. Before running Intent on a live system, establish explicit deployment constraints. Worker agents are eager. Give them boundaries.
Budget intentionally. Understand your credit consumption rate before committing to a large project. The Max plan is the right tier for serious development work, but heavy agent spread will burn through it faster than casual usage suggests.
The Bigger Picture
Something important is happening in the world of software development, and Intent is one of its clearest expressions. The skill that defined the best engineers for fifty years — the ability to write excellent code — is being joined, and in some contexts replaced, by a different skill: the ability to orchestrate excellent code production.
Addy Osmani, Google’s Chrome Engineering Director, described this arc as the evolution from Coder to Conductor to Orchestrator. Nicholas Zakas, creator of ESLint, went further: ‘The software engineering job of the future won’t involve writing code; it will involve orchestrating AI agents to write code for you.’ I have spent thirty years building technology. I have never seen a transition this fast or this fundamental.
What I can tell you from five days inside it is that Augment’s Intent is the most compelling vision I have encountered of what orchestrated software development actually feels like in practice. When you set it up right, when the coordinator has the context it needs, when the workspaces are appropriately scoped, and when you are monitoring the right signals, it genuinely feels like wishing a project into existence. Not because the technology is magic. Because the technology is finally sophisticated enough to take your intent seriously.
“When you set it up right, it genuinely feels like wishing a project into existence. Not because the technology is magic. But because it is finally sophisticated enough to take your intent seriously.”
The orchestrator era is here. The tools are imperfect, the costs are real, the discipline required is substantial, and the learning curve is steeper than the demos suggest. But the direction is unmistakable.
We are moving from writing code to directing intelligence. And the teams that learn to direct it well — with clear context, disciplined decomposition, and architectural judgment — are going to build things that the rest of the world cannot yet imagine.
Sources & Further Reading
• Augment Code: Intent — A Workspace for Agent Orchestration. augmentcode.com/blog/intent-a-workspace-for-agent-orchestration
• Addy Osmani: The Future of Agentic Coding — Conductors to Orchestrators. addyosmani.com/blog/future-agentic-coding
• Anthropic: 2026 Agentic Coding Trends Report. resources.anthropic.com
• Google Developers: Build With Google Antigravity, Our New Agentic Development Platform. developers.googleblog.com
• Google Labs: Jules — Google’s Autonomous AI Coding Agent. blog.google/technology/google-labs/jules
• Kilo Code: Testing Augment Code’s New Credit System with 4 Real Tasks. blog.kilo.ai
• Mike Mason: AI Coding Agents in 2026 — Coherence Through Orchestration, Not Autonomy. mikemason.ca
• VentureBeat: The Creator of Claude Code Just Revealed His Workflow. venturebeat.com
• Augment Code Pricing and Plans. augmentcode.com/pricing
Augment Code Intent Documentation. docs.augmentcode.com/intent/overview
About the Author
Dr. Tali Režun is a Serial Entrepreneur, Business Developer, and Academic at the forefront of frontier technologies. As Vice Dean of Frontier Technologies at COTRUGLI Business School, he leads AI innovation initiatives and shapes MBA curricula for the next generation of technology leaders. With over 30 years of entrepreneurial experience — founding and scaling ventures including Lumina AI, Moj AI, Block Labs, CR Systems, 4thTech, Immu3, PollinationX, and Online Guerrilla — he bridges cutting-edge research in AI and Web3 with practical business transformation.
Tali’s Links
— https://talirezun.com/
— https://x.com/talirezun
— https://www.linkedin.com/in/talirezun
— https://www.researchgate.net/profile/Tali-Rezun
— https://luminawidget.xyz/
Disclaimer
Research and Educational Purpose
This article is published for research and educational purposes only. The content represents our personal experiences, observations, and analysis based on extensive hands-on experimentation with AI agent technologies over the past eighteen months.
No Commercial Relationships
We have not been compensated, sponsored, or otherwise financially supported by any of the companies, platforms, or tools mentioned in this article, including Augment Code, OpenAI, Google, or any other technology provider referenced herein. All opinions, assessments, and recommendations are my own and based solely on independent research and practical experience.
Individual Research Required
Readers are strongly encouraged to:
Conduct their own independent research before adopting any AI agent technology
Evaluate tools and platforms based on their specific use cases, requirements, and risk tolerance
Test systems thoroughly in controlled environments before production deployment
Consult with relevant technical, legal, and security professionals when implementing AI agents in business-critical or sensitive applications
Stay informed about evolving best practices, security considerations, and regulatory requirements
No Guarantees or Warranties
While I have made every effort to ensure accuracy based on my research and experience, I make no guarantees regarding the performance, reliability, security, or suitability of any AI agent technology for any particular purpose. Technology capabilities and limitations may vary significantly based on implementation details, use cases, and environmental factors.
Evolving Landscape
The AI agent ecosystem is developing rapidly. Tools, platforms, protocols, and best practices referenced in this article may be superseded, deprecated, or fundamentally changed by the time you read this. Always verify current capabilities and recommendations with primary sources and official documentation.
Your Responsibility
You are solely responsible for evaluating whether and how to implement AI technologies in your specific context. Consider your risk tolerance, regulatory requirements, security needs, and organizational capabilities before implementation.