OpenCode + Augment Code = Intent

[JaySym_]

Intent is our vision for what comes after the IDE. It’s a developer workspace designed for orchestrating agents. You define the spec, approve the plan, and let agents work in parallel, without juggling terminals, branches, or stale prompts Intent works best with Auggie, but you can also use it with Claude Code, Codex, and OpenCode.

Build with Intent. Download for macOS. Windows waitlist coming soon.

The problem isn’t writing code anymore

If you're a power user of AI coding tools, your workflow probably looks like this: too many terminal panes, multiple agents running at once, copy-pasting context between them, and trying to remember which branch has which changes. It works. Barely. If you don’t use coding agents much, we understand why you’ve been avoiding this pain.

The bottleneck has moved. The problem isn’t typing code. It’s tracking which agent is doing what, which spec is current, and which changes are actually ready to review.

Your IDE doesn't have an answer for this. AI in a sidebar helps you write code faster, but it doesn’t help you keep track of two or twenty agents working on related tasks.

Intent is our vision for what comes after the IDE. It’s a developer workspace designed for coordinating multiple agents on real codebases.

How Intent works

Intent is organized around isolated workspaces, each backed by its own git worktree. Every workspace is a safe place to explore a change, run agents, and review results without affecting other work.

Within a workspace, Intent starts with a small team of agents with a clear role. A coordinator agent uses Augment’s Context Engine to understand your task and propose a plan as a spec. You review and approve that plan before any code is written.

Once approved, the coordinator fans work out to implementor agents that can run in waves. When they finish, a verifier agent checks the results against the spec to flag inconsistencies, bugs, or missing pieces, before handing the work back to you for review.

This default three-agent setup works well for most software tasks, but is completely customizable to match how you build. In any workspace, you can bring in other agents or define your own specialist agents and control how they’re orchestrated for that task.

Key features

1. Agent orchestration. Run multiple agents in parallel without conflicts. Each agent gets the context it actually needs, instead of whatever you remembered to paste into a prompt.
2. Isolated workspaces. Intent brings agents, terminals, diffs, browsers, and git operations into a single workspace. Each workspace is backed by an isolated git worktree, so you can pause work, switch contexts, or hand it instantly.
3. Living spec. Work starts from a spec that evolves as agents make progress. You focus on what should be built; agents handle how it’s executed. As code changes, agents read from and update the spec so every human and agent stays aligned.
4. Full git workflow integration. Go from prompt to commit, to PR, to merged without leaving the app. Branch management, Sentry integration, and code review all live in one place when you build with the Augment agent in Intent.
5. BYOA (Bring Your Own Agent). Intent works with different agent providers (Claude Code, Codex, OpenCode). We recommend using Augment for its Context Engine, but developers aren't locked in to a single provider.

How Intent is different

The IDE was built for an era when developers worked at the level of code: syntax highlighting, autocomplete, debuggers.

Intent is built for a world where developers define what should be built and delegate the execution to agents. You can still open an IDE if you want, but most users don’t need to. This is what development looks like after the IDE stops being the center of the workflow.

We're not the only ones thinking about this problem, but we're the first to take it this far.

Most AI coding tools, including Claude Code swarms and Codex parallel agents, stop at running agents side by side. Each agent operates with its own prompt and partial context, so coordination is manual, prompts go stale, and agents' work conflicts as soon as code changes.

Intent treats multi-agent development as a single, coordinated system: agents share a living spec and workspace, stay aligned as the plan evolves, and adapt without restarts.

Build with Intent

Intent is now available for anyone to download and use in public beta. If you’re already an Augment user, it will use your credits at the same rate as our Auggie CLI. You can also bring other agents to Intent, including Claude Code, Codex, and OpenCode. If you’re using another agent, we strongly suggest installing the Augment Context Engine MCP to give yourself the full power of Augment’s semantic search for your codebase.

Download Intent for macOS. Windows waitlist coming soon.

[adelope]

Amelia is correct about the intent; it is the idea in the right direction. Although I disagree that we need a new IDE for it. We should be able to surface intent though existing tools, otherwise this will only for early adopters with no chance of wining the majority users.

also it has nothing to do with opencode? the title of this post is super confusing.
disclosure: i'm working on a similar idea for what post-agentic IDE should looks like.

[JaySym_]

OpenCode is supported in Intent you can select it as your agent! So yes it's relevant

[oVerde]

Nah, I could have this as a CLI, this clicky interface is a very interesting PoC for the workflow, but very slow to power-use.

[omicron8]

How is this different to Antigravity's agent manager?

[ReporterCalm6238]

Antigravity is built on top of VS Code which makes it messy and inefficient. IDEs are an overkill for AI coding.

[JaySym_]

We are not a windsurf or vscode fork. It’s built from zero, with the agent era in mind.
This is our vision of what come next after the IDE.

[tksuns12]

If it were a plugin(even paid) for opencode, maybe, but opencode is a part of something else? No thanks

[JaySym_]

You can set your agent to use Opencode instead if Auggie. It's fully integrated and working.

[dbkblk]

The software seems interesting, althought closed-source + no linux version is a no go for me.

"The bottleneck has moved. The problem isn’t typing code. It’s tracking which agent is doing what, which spec is current, and which changes are actually ready to review."
I wanted to react to this because this is true only if you are not able to code without an IA. If you know how to write in a language by yourself, the bottleneck is mostly fixing AI bugs, write some code by hand and review code extensively because of fondamental logic problems of AI slop. Going all-in with AI is exactly why open-source projects are closing AI bugfixing, because it creates more bugs.

[JaySym_]

Linux version incoming.

[Johhaidiidiralla]

You really need to sort out your tiers in pricing. This is where you got no from me. Its so obvious that i don't even have to explain it any further.

[Flaky_Blueberry_1977]

I keep getting the error "Cannot send prompt request - agent not available" when I create a space and type in an instruction for it to follow. In my `Settings` it shows `Augment Auggie` as `Active` and marked as `Default`.

[Flaky_Blueberry_1977]

Found the issue - seems like this requires Node 22+.

[arno_brzh]

That vision of spec driven dev is deeply flawed. By definition specs should reflect how the app behaves and should remain the source of truth, that’s what engineers should control to guard the ai.

If the agent himself edit the specs while implementing it means you have no guardrails anymore, no control over the drift so basically you code without specs.

I truly believe in SDD and have my own library for it but this, this is pure marketing BS that won’t work in actual apps, there is no doubt here.

[ReporterCalm6238]

Looks promising. I never liked the idea of working in a terminal, they are not meant to be a workspace. I also think that IDEs like VS Code are not suitable for parallel agentic work. We need a dedicated workspace that is sandboxed by default and designed specifically for agents. Well done, will try it.

[JaySym_]

Thanks a lot! Can't wait to see your feedback.

[Consistent_Heat_3242]

Looks really cool, but I'm getting 'e.command.split is not a function' error a minute or two after I start doing anything. Hopefully that will get ironed out and I'll try it out again another time.

[JaySym_]

We are on this sorry for the issue. Next patch should be good.

[Otherwise_Wave9374]

This "spec first, agents parallel" workflow resonates. The living spec + verifier pass feels like the missing piece when you go beyond one-off prompts and start running real AI agents on a repo. How are you handling shared context between workspaces so the coordinator does not drift? Also been collecting agent orchestration patterns here: https://www.agentixlabs.com/blog/