The next step for agents is moving beyond just text.
Today, we're launching Agent-Native in beta: an open-source TypeScript framework for building AI agents with intuitive UIs.
You can start locally with the open-source framework, or build your own online with Builder.io.
The Agent-Native beta includes:
- An open-source framework for agents with UIs. Each agent comes with its own app, and the agent and UI share the same actions, data, and application state.
- Shared actions across six surfaces. Define a capability once, and Agent-Native exposes it to the UI, agent, HTTP API, CLI, MCP, and A2A.
- Connections to your tools and other agents. Connect tools like Slack and Notion over MCP, use your app from Claude, ChatGPT, or Cursor, and delegate tasks between agents with A2A.
- Built-in team features. Shared instructions, skills, and memory, plus authentication, permissions, and real-time collaboration.
- Local or online development. Build locally and host anywhere, or build and deploy online with Builder.io.
Every kind of work has an interface that helps people do it. We shape presentations in slide editors, explore ideas in design tools, and track what's happening in dashboards. These interfaces make the work visible and give us direct ways to change it.
AI agents bring a new way to work: describe the outcome you want and let the agent figure out the steps. But handing off a task doesn't remove the need to see the result, make a judgment, or adjust a detail. That kind of visual, hands-on work is hard to do through chat alone.
Fixing one color shouldn't mean writing a prompt, waiting for the agent, paying for the tokens, and checking that nothing else changed. People should be able to move between asking an agent and doing the work themselves, whichever fits the task. That takes both: the freedom of a prompt, with the control of an app.
An agentic app is an AI agent that comes with its own app, and the two work as one. It isn't a chat sidebar added to an app: the agent and the UI are equal partners, so anything you can do in the UI, the agent can do too.
Together, they give you what a chat box on its own can't:
- A clear place to start. The UI shows what the agent can do, so you don't have to guess what to ask.
- Context that's already there. Your data and workflow live in the app, so the agent starts from what you're working on.
- Work you shape together. Results appear in the UI as the agent works. Keep editing alongside it, select anything to point it there, or hand a task back to it.
Agent-Native connects the agent and the UI through three shared foundations.
Shared actions give them the same capabilities. You define each capability once. The agent calls it as a tool, and the UI calls it from code. Both go through the same validation, permissions, and implementation.
Shared data keeps their work in sync. Work the agent does appears in the UI, and changes you make in the UI are available to the agent.
Shared application state provides context. The agent knows what's on your screen, such as the current page, the selected record, or the active view, so it understands what you mean by "this."
Computer-use agents work through the UI the way a person would. They look at the screen, decide where to click or type, act, then check the result, one step at a time. It works, but it's slow and token-heavy.
Agent-Native agents skip the screen and call the same actions the UI uses. They know exactly what they can do, finish faster, and spend fewer tokens. And with no screen to depend on, they can also run from Slack, on a schedule, or at another agent's request.
Agent-Native works in both directions: your agent can reach the apps your team uses, and other AI tools and agents can reach your app.
Message your agent from Slack, Microsoft Teams, Discord, email, Telegram, or WhatsApp, and it gets to work without you opening the app. Connect it to the rest of your tools, like Notion, Linear, and GitHub, through MCP and built-in connections, so it can pull information together and act across them.
Every Agent-Native app supports the Agent-to-Agent (A2A) protocol. One agent can hand a task to another, which handles it with its own tools and context and returns the result. Each agent you build adds capabilities the others can draw on.
Every Agent-Native app is also an MCP server. Connect it to Claude, ChatGPT, Cursor, or Codex, and those tools can call your app's actions directly. In hosts that support MCP Apps, your app's UI renders right in the conversation.
A general-purpose agent is only as good as what it knows about your work. Every agent you build with Agent-Native can have instructions, skills, memory, and files for context.
Instructions and skills can be shared across your team, while each person also keeps their own preferences and memory. When someone improves a shared skill, everyone benefits.
For specialized work, add sub-agents, each with its own thread, instructions, and tools. Your agent can also run on a schedule or when an event happens, with conditions written in plain language.
Agent-Native includes the parts every app needs and you'd rather not build yourself: authentication, permissions, organizations and teams, data storage, multi-tenancy, and live sync.
Handing work to an agent is easier when you can see what it's doing. You can watch its progress as it works, require your approval before sensitive actions, and always tell whether a change came from you, a teammate, or the agent.
The optional Agent-Native Toolkit adds ready-made building blocks for the rest of your app. Clips, Slides, and Design are built with the same pieces:
- Editing: rich text editors and canvas controls.
- Collaboration: real-time presence, sharing, and comments.
- History: version history, undo, and restore.
- App setup: settings, teams, navigation, and connections.
Bring your own API key for Anthropic, OpenAI, Google Gemini, OpenRouter, or any OpenAI-compatible endpoint, run a local model with Ollama, or use Builder.io's managed AI connection. You can switch models without changing your app: your actions, data, and UI stay the same.
You can also try running Codex models on your existing ChatGPT subscription, an experimental option in Labs.
Start locally if you want the code in your own environment. Build with your coding agent or edit the code yourself:
npx @agent-native/core@latest create my-appThe code lives in your repository. Bring any PostgreSQL database, such as Neon or Supabase, and deploy to Node, Vercel, Netlify, Cloudflare, or AWS.
Already have a React app? Add an agent panel to it without starting over.
Or build online with Builder.io. Describe what you want, refine it with AI, and share it with your team, with no local setup.
Clips, Slides, and Design are agentic apps built with Agent-Native. Try them to see what an agent and its app can do together:
- Clips: Record your screen and share it with your agent. One link gives it the transcript and timestamped images, so it can act on bugs, feedback, and walkthroughs.
- Slides: Ask the agent for a deck, then edit the slides yourself. Select any slide, and the agent knows which one you mean.
- Design: Create designs and interactive prototypes with the agent, then fine-tune them with visual controls or hand them back to the agent.
All three are open source. Use them, see how they're built, or start your own app from one.
Pick a workflow you know well and build an AI agent for it, with a UI that lets people see, edit, and guide its work.
