What is Intent?

Intent is a free desktop app that replaces the traditional IDE with a purpose-built interface for agentic software development, centered on spec-driven development and multi-agent orchestration.

Traditional IDEs were designed for humans writing code by hand. As AI agents take on more of the coding work, a single-agent view in an IDE becomes limiting. Intent gives you a unified workspace to coordinate multiple agents, stay aligned on what you actually want built, and reduce the costly back-and-forth that comes from misalignment between your goal and what the agent assumes.

Key Concepts

Spec-driven development

When you give a prompt, a coordinator agent generates a living spec document that captures assumptions, requirements, and design decisions. You review and refine it before any code gets written, keeping your intent aligned with the output throughout the project.

Multi-agent orchestration

A coordinator agent breaks work into tasks and delegates them to specialized sub-agents (UI designer, implementer, etc.) that run in parallel. You communicate with the coordinator and it manages the rest.

Built-in browser verification

Agents can open a browser inside the app, click through your web app, and do end-to-end testing autonomously before marking a task as done.

Bring your own agent

Works with Claude Code, Codex, or OpenCode as the underlying agent provider, so no Augment subscription is required. You can also assign different models to different sub-agents.

MCP support

You can plug in any MCP server (including Augment's context engine for cross-repo awareness), and agents can use skills and custom tools through this system.

Spaces and layout

Each project lives in a “space” you can switch between. The UI is fully customizable with split views for specs, agent activity, code diffs, file trees, and the browser.

Setup

1. Go to Settings to configure your agent provider and default model.
2. Create a new “space” for each project.
3. Point it at an existing repo and choose to work off the main branch in a new worktree, or work directly in the folder.

Getting Started

Intent is a desktop app for AI-assisted software development. You work inside workspaces — each one wraps a git branch with its own AI agents, notes, and file tracking. You describe what you want built, and agents write the code.

Install & Launch

1. Download Intent from intentapp.dev
2. Prerequisites: Node.js 22+ and Git installed
3. Open the app — you’ll land on the home screen showing all your workspaces

Prerequisites

• Make sure you have Node.js 18+ installed — grab it from nodejs.org
• You’ll need Git — download it from git-scm.com
• Install an agent provider and log in to it with your account.
• Intent works with agent providers like Auggie, Claude Code, or Codex. You’ll need at least one to use Intent.

Create Your First Workspace

From the home screen, pick one of three starting points:

• Local repo — Point to an existing project folder on your machine
• GitHub clone — Paste a repo URL and Intent clones it for you
• Start from scratch — Describe what you want to build and an agent creates it

Each workspace gets its own git branch automatically, so your main branch stays untouched.

Have Your First Conversation

Once inside a workspace:

1. Type a prompt in the chat input at the bottom — describe what you want (“Add a dark mode toggle to the settings page”)
2. Watch the agent work — it reads your code, edits files, runs commands, and streams its thinking in real time
3. Review the changes — open the Changes panel in the sidebar to see file diffs
4. Accept or adjust — if the changes look right, commit them. If not, tell the agent what to fix.

That’s the core loop: prompt → agent works → review → iterate.

What to Try Next

• Write a Spec to give the agent a structured plan (see Notes & Spec)
• Use a specialist like the Coordinator to break big projects into tasks (see Agents & Chat)
• Open the terminal with Ctrl+` to run commands alongside the agent

Key Terms

Workspaces

A workspace is your project’s home base in Intent. It bundles a git branch, AI agents, notes, and an activity log into one isolated environment. You can have many workspaces open — one per feature, bug fix, or experiment.

Creating a Workspace

From the home screen, click New Workspace and choose:

Intent creates a dedicated git branch (e.g., intent/add-dark-mode) so your main branch is never touched directly.

The Home Screen

All your workspaces appear on the home screen, grouped by recency. Each card shows:

• Workspace name and status message
• Branch name and repo
• Agent activity summary
• Task progress (if a Spec has tasks)

Switching Between Workspaces

• Cmd+O — Opens the Spaces switcher overlay. Type to search, click to switch.
• Ctrl+Tab / Ctrl+Shift+Tab — Cycle through recent workspaces.

The Workspace Sidebar

Once inside a workspace, the left sidebar has several tabs:

Toggle the sidebar with Cmd+B.

Managing Workspaces

• Rename — Click the workspace title in the sidebar header to edit it
• Archive — From the home screen, archive workspaces you’re done with
• Delete — Permanently remove a workspace and its metadata (the git branch remains unless you delete it separately)

Workspace Settings

Each workspace can have its own:

• Git configuration — Remote, base branch
• MCP servers — Extra tool servers for agents
• Setup scripts — Commands that run when the workspace initializes (e.g., pnpm install)

Agents & Chat

Agents are AI assistants that live inside your workspace. They read your code, edit files, run terminal commands, and use tools — all while streaming their work to you in real time. Agents are powered by an external agent provider (like Auggie, Claude Code, or Codex) — make sure you have at least one installed before getting started.

Starting an Agent

• Cmd+T — Opens a new agent tab
• Cmd+N — Creates a new agent from anywhere
• Type your prompt and press Enter to send

You can have multiple agents running simultaneously in the same workspace.

Agent Specialists

Not all agents are the same. Intent has built-in specialists — agents pre-configured for specific roles:

Select a specialist when creating a new agent, or let the default handle general tasks.

Multi-Agent Workflows

For bigger projects, the Coordinator pattern works well:

1. You describe the goal to a Coordinator agent
2. It writes a plan in the Spec note with @@@task blocks
3. You approve the plan
4. It delegates tasks to Implementor agents (they work in parallel)
5. A Verifier agent checks the results
6. You review and merge

Use Follow Mode (Cmd+Shift+F) to watch agents work in real time. Arrow keys cycle between active agents.

Reviewing Agent Work

After an agent makes changes:

• Changes panel (sidebar) — Shows all modified files as diffs
• Click a file — Opens a side-by-side diff view
• Accept — Commit the changes
• Reject — Tell the agent what to fix, or undo

Controlling Agents

What Agents Can Do

Agents have access to tools that let them:

• Read and edit files in your repo
• Run terminal commands
• Open and interact with a browser (for UI testing)
• Read and write workspace notes
• Make git commits and create pull requests
• Use MCP servers for external integrations

Notes & Spec

Notes are persistent documents inside your workspace. They’re shared between you and your agents — anything you write, agents can read, and vice versa. The most important note is the Spec.

The Spec Note

Every workspace has a Spec note. It’s the planning document — the source of truth for what the workspace is trying to accomplish.

A good Spec includes:

• Goal — One sentence: what’s the user-visible outcome?
• Tasks — Broken down using @@@task blocks (see below)
• Acceptance Criteria — How do you know it’s done?
• Non-goals — What’s explicitly out of scope

Agents read the Spec before starting work. A clear Spec = better agent output.

Creating & Editing Notes

• Open the Notes tab in the sidebar (Cmd+Shift+N)
• Click + New Note to create one
• Notes use a Markdown editor with rich formatting (headings, lists, code blocks, images)
• Add tags to organize notes
• All changes save automatically

Task Blocks

To create trackable tasks, use @@@task blocks in any note:

@@@task
# Add user authentication
## Scope
- Login/logout endpoints
- JWT token management
## Definition of Done
- All auth endpoints return correct status codes
- Tests pass
@@@

When you save the note:

1. Each @@@task block converts into a Task Note
2. The block is replaced with a linked checkbox
3. Agents can be assigned to Task Notes and update their status

Rules:

• One task per @@@task block
• The first # Heading becomes the task title
• Everything below is the task body

Rich Blocks

Notes support special blocks that make documentation actionable:

Comments

You can leave inline comments on any note:

• Highlight text and click Comment
• Agents can comment too — useful for questions or suggestions
• Comments appear as threads anchored to specific text
• Resolve threads when addressed

Comments are great for async collaboration between you and your agents.

Git & Code Changes

Intent has built-in git integration. Every workspace tracks a git branch, and you can view changes, commit, create PRs, and merge — all without leaving the app.

Branch Per Workspace

When you create a workspace, Intent creates a dedicated git branch (e.g., intent/add-dark-mode). All agent work happens on this branch, keeping your main branch clean.

The branch name appears in the sidebar header.

Viewing Changes

Open the Changes tab in the sidebar (Cmd+Shift+G) to see:

• Modified files — Files the agent (or you) changed
• Staged files — Files ready to commit
• Untracked files — New files not yet tracked by git

Click any file to open a side-by-side diff showing exactly what changed.

Committing

Two ways to commit:

1. Agent auto-commit — Agents commit their own work with descriptive messages as they go
2. Manual commit — Open the Commit drawer in the sidebar, stage files, write a message, and commit

Pull Requests

From the PR section in the sidebar:

• Create a PR — Intent pre-fills the title, description, and target branch
• View PR status — See CI checks, review comments, merge state
• Address review comments — Agents can read and respond to PR feedback
• Merge — Merge directly from Intent when the PR is ready

The PR Shepherd specialist can automate the entire process of getting a PR to a merge-ready state.

Commit History

The Activity tab (Cmd+Shift+A) shows a timeline of commits alongside agent actions, giving you a clear picture of what happened and when.

Panels & Layout

Intent’s interface is built around a flexible panel system. You can split, resize, and rearrange panels to match how you work.

The Three Zones

The screen is divided into three zones:

Toggle the sidebar with Cmd+B.

Splitting Panels

• Cmd+\ — Split the current panel horizontally
• Cmd+Shift+\ — Split vertically

Drag tabs between panels to rearrange. Drag a panel edge to resize.

Layout Presets

Quick layouts for common setups:

Tabs

Each panel can have multiple tabs:

Leader Key (Power Users)

Press Cmd+; to enter leader mode, then press a key within 2 seconds:

Terminal

Intent has a built-in terminal so you can run commands without switching apps. It slides down from the top like a quake-style console.

Opening the Terminal

• Ctrl+` — Toggle the terminal overlay (works on all platforms)
• Cmd+J — Alternate toggle shortcut

The terminal appears as an overlay on top of your workspace. Press the same shortcut to hide it.

Multiple Tabs

You can run several terminals at once:

Agents & Terminals

Agents can run terminal commands as part of their work — installing dependencies, running tests, starting dev servers. You’ll see their terminal output in real time.

When an agent starts a long-running process (like a dev server), it appears as a managed script in the workspace and keeps running in the background.

Browser Panel

Intent includes a built-in web browser for previewing web applications without leaving the app.

Opening the Browser

The browser panel opens when:

• An agent starts a dev server and navigates to it
• You open a URL from agent output or a note
• You manually navigate to a URL in the browser panel

Dev Server Preview

When an agent runs a dev server (e.g., pnpm dev), it can automatically open the browser panel to the local URL. As the agent makes changes, you see updates in real time.

Navigation

Agent Browser Interaction

Agents can use the browser programmatically via Chrome DevTools Protocol (CDP):

• Take screenshots to verify UI changes
• Inspect the page for layout, accessibility, and console errors
• Interact with elements to test functionality

This is especially useful with the UI Designer and Verifier specialists, who use the browser to validate their work visually.

Settings & Configuration

Open Settings with Cmd+, to configure Intent.

AI Providers

Configure which AI providers agents use:

• Augment — Built-in provider, no API key needed if you have an Augment account
• Other providers — Add API keys for additional providers as available

Set the default model for new agents. Different specialists may use different model tiers (fast, balanced, smart).

MCP Servers

MCP (Model Context Protocol) servers give agents access to external tools — databases, APIs, design tools, and more.

• Add servers globally (all workspaces) or per-workspace
• Each server provides a set of tools agents can call
• Configure in Settings → MCP Servers

Theme

• Light / Dark / System — Follows your OS preference by default
• Change in Settings → Appearance

Fonts & Display

• Agent font style — Choose how agent messages look
• Code font — Pick the monospace font for code blocks and the editor
• Note font — Serif or sans-serif for note content

Connections

Link external accounts for deeper integration:

Rules & Skills

Customize how agents behave:

• AGENTS.md — A file in your project root that agents read automatically. Define conventions, tech stack, and guidelines.
• User rules — Personal rules applied across all workspaces.
• Skills — Specialized instruction sets agents load for specific tasks (e.g., Redux work, Electron automation).

Rules are the best way to get consistently good output from agents — tell them your project’s patterns once, and every agent follows them.

Keyboard Shortcuts

Quick reference for Intent keyboard shortcuts.

Global

Workspace Navigation

Tabs & Panels

Layout Presets

Chat & Agents

Terminal

Browser

Leader Key (Cmd+;)

Tips

• Think workspace-first, not chat-first. Intent is built around workspaces, not conversations. Treat it as “the place where one task lives,” not “where I talk to an agent.”
• Use one workspace per real task. Each workspace gets its own Git worktree for isolation. If the work is separate (a feature, a bug fix, a review), the workspace should be separate.
• Don’t create a new workspace for every agent chat. Multiple specialist agents can collaborate within a single workspace. If the work is the same task, keep it in the same workspace and let agents coordinate there.
• Invest in setup scripts early. Since each workspace spins up a fresh worktree, things like .env files won’t carry over automatically. Build reliable bootstrapping scripts that copy environment files, seed data, and local secrets when a new workspace starts.
• Use the built-in browser as part of the workspace. Each workspace has its own isolated browser state. Keep your running app, test flows, and visual checkpoints attached to the workspace instead of recreating them from scratch each time.
• Customize your specialist agents. The default agent behaviors aren’t fixed. If the coordinator is too verbose, too passive, or not structured the way you want, shape those prompts to match your actual workflow.
• Think in orchestration, not single-agent magic. Ask yourself: what specialists should operate in this workspace, what context do they need, what notes should anchor them, and how should they coordinate?
• Use a meta workspace for long-term project memory. When a project needs persistent context across multiple tasks, a dedicated meta workspace can serve as that anchor.