Don't choose between rich user interfaces and autonomous agents. Every Agent-Native app is both.

The agent and the UI are equal citizens of the same system. Every action works both ways — click it or ask for it.

• Everything syncs — Agent and UI share one database and one state. Changes from either side show up instantly on the other.
• Real-time multiplayer — Humans and agents collaborate in the same document simultaneously: CRDT merging, live presence (cursors, selection rings, who's on which slide), and the agent as a first-class peer editor. Works on any SQL database and any host, including serverless.
• Context-aware — The agent knows what you're looking at. Select text, hit Cmd+I, and tell it what to do.
• Per-user workspace — Skills, memory, instructions, sub-agents, and MCP servers — SQL-backed, customizable per user. Claude-Code-level flexibility, SaaS-grade economics.
• Agents call agents — Tag another agent from any app. They discover each other over A2A and take action across your stack.
• Reusable integrations — Connect a provider once in Dispatch, keep secret values in the vault, then grant apps like Brain, Analytics, Mail, and Dispatch access to the shared account metadata and credential refs.
• Three shapes — Build the same agent as a headless API, a rich chat experience, or a full application where agent and UI stay in sync.
• Apps that improve themselves — Your apps get better on their own. The agent can add features, fix bugs, and refine the UI over time.
• Any database, any host — Any SQL database Drizzle supports. Any hosting target Nitro supports. No lock-in.
• Bring the agent surface you need — MCP-compatible hosts can call your apps, coding agents can install skills, native chat renders reusable app outputs, and BYO agent runtimes can stream into the Agent-Native chat shell.

Agent-Native is an open-source framework for building robust agents that can act inside real apps, not just chat next to them.

It gives you primitives for product-grade agentic software: shared actions, SQL-backed state, identity, tools, skills, jobs, observability, and UI surfaces that all work together.

Backend agnostic: bring your own database, hosting provider, model stack, and app code.

// One action powers UI, agent, HTTP, MCP, A2A, and CLI.
export default defineAction({
  schema: z.object({
    emailId: z.string(),
    body: z.string(),
  }),
  run: async ({ emailId, body }) => {
    await db.insert(replies).values({ emailId, body });
  },
});

• Actions — Define work once. Use it from UI, agent, API, MCP, A2A, and CLI.
• Agent runtime — Chat, tools, skills, memory, jobs, observability, and handoffs ship together.
• Backend agnostic — Plug in any Drizzle-supported SQL database and Nitro-compatible host.

Agent-Native primitives let you choose how much UI to put around an agent without rebuilding the agent contract:

Protocols come with the framework instead of becoming separate integrations per feature. Today that means A2A, MCP, MCP Apps, standard remote MCP OAuth, MCP clients, HTTP/CLI action calls, native chat widgets, AgentChatRuntime adapters, standard OpenAI, AG-UI, Claude Agent SDK, and Vercel AI SDK chat runtime connectors, and deep links all hang off the same action surface. ACP is best understood as the coding-agent/editor interoperability protocol, not the general BYO app-chat runtime.

For the full decision guide — headless, rich chat on the built-in agent, rich chat on your own agent, embedded sidecar, or full app — see Agent Surfaces.

To connect Claude, ChatGPT, Codex, Cursor, OpenCode, GitHub Copilot / VS Code, or another MCP host to your hosted app, see the External Agents guide.

Don't want to scaffold a whole app yet? Add visual planning and PR recaps to Claude Code, Codex, Cursor, Pi, OpenCode, GitHub Copilot / VS Code, and similar agents with one command:

npx @agent-native/core@latest skills add visual-plan

You get two slash commands that upgrade how your agent plans and reports its work:

• /visual-plan — before the agent writes code, it opens a structured, reviewable plan document instead of a wall of text: inline diagrams, UI wireframes and prototypes, file-by-file implementation maps, and annotations you can comment on and approve.
• /visual-recap — after changes land, it turns a PR or git diff into a high-altitude visual recap: schema, API, and file changes rendered as grounded before/after blocks with a shareable review link, instead of scrolling a raw diff.

See the Skills Guide for more skills and local installs.

Start with a full featured template. Each one is a complete, 100% free and open-source SaaS app — cloneable, not scaffolded — except you own the code and can customize everything.

Every template is a complete cloneable SaaS — fork it, customize it with the agent, own it. Try them with example data before connecting your own sources.

View the full template gallery at agent-native.com/templates.

One command to fork a template and start building locally.

npx @agent-native/core@latest create my-platform
cd my-platform
pnpm install
pnpm dev

The CLI shows a multi-select picker so you can include as many templates as you want in one workspace. Pick Mail + Calendar + Forms and you get all three apps wired up and sharing auth in one go. Or browse the template gallery for live demos.

Want a single app, no monorepo? Use --standalone:

npx @agent-native/core@latest create my-app --standalone --template mail

A workspace is the default shape of an agent-native project. Every app sits under apps/, and packages/shared/ is available for the small amount of code, instructions, skills, or branding that should truly apply to every app.

my-platform/
├── package.json                   # declares `agent-native.workspaceCore`
├── pnpm-workspace.yaml
├── .env                           # shared secrets: ANTHROPIC_API_KEY, BUILDER_PRIVATE_KEY, A2A_SECRET, ...
├── packages/
│   └── shared/                    # optional shared custom code
└── apps/
    ├── mail/
    ├── calendar/
    └── forms/

Add another app later:

npx @agent-native/core@latest add-app notes --template content

Deploy every app behind one origin:

npx @agent-native/core@latest deploy
# https://your-agents.com/mail/*       → mail
# https://your-agents.com/calendar/*   → calendar
# https://your-agents.com/forms/*      → forms

Same-origin deploy means a shared login session across every app and zero-config cross-app A2A — tag @mail from the calendar's agent chat and it just works (no JWT signing, no CORS). Full details at agent-native.com/docs/multi-app-workspace.

Join the Discord to ask questions, share what you're building, and get help.

Full documentation at agent-native.com.

MIT