---
title: "What is Agent-Native?"
description: "What Agent-Native is, why agents need UIs, how its shared action architecture works, and when to use it."
---

# What is Agent-Native?

Agent-Native is an open-source TypeScript framework for building autonomous
agents with intuitive UIs. You define each capability once as an
[action](/docs/actions-overview)—a typed function the agent uses as a tool and
the UI calls from code.

## Why build agents with UIs

Coding agents can make a text box seem like enough. But the text box is only
one part of their working environment. The codebase provides context, tools
give them clear ways to act, and files, tests, and previews make the results
visible.

Most knowledge work does not come with that structure. In a blank text box,
people have to guess what the agent can do, what context it has, and what they
should ask.

A UI provides what the text box is missing. It makes the agent's capabilities
visible, brings context and workflows into the experience, and lets people see
and shape the work as it develops.

Agent-Native lets you build agents this way. The UI gives people clear starting
points without reducing the agent to a fixed workflow. Because the agent and UI
use the same capabilities, people can delegate work to the agent, inspect or
change it in the UI, and move between the two without losing progress.

## How Agent-Native works

<Video
  src="https://cdn.builder.io/o/assets%2Fc5b47d20f6a943e485717e5895739988%2Fc88d506c160142ae9b8618616ceedcea%2Fcompressed?apiKey=c5b47d20f6a943e485717e5895739988&token=c88d506c160142ae9b8618616ceedcea&alt=media&optimized=true"
  alt="A comparison of a person using an application directly and working through an AI agent in the same application."
  align="full"
  caption="Watch a four-minute introduction to Agent-Native architecture."
/>

Agent-Native connects the agent and UI through three shared foundations:

- **[Shared actions](/docs/actions-overview).** You define each capability once.
  The agent calls it as a tool, and the UI calls it from code. Both paths use
  the same validation, permissions, and implementation.
- **[Shared data](/docs/server-database).** Actions read and update the same
  data, so work done by the agent appears in the UI, and work done in the UI is
  available to the agent.
- **[Shared application state](/docs/context-awareness).** Application state
  describes what is happening in the UI, such as the current page, selected
  record, or active view. Agent-Native gives the relevant state to the agent as
  context, so it understands what the person is working with.

The agent does not click through the UI. It works through the same action layer
as the UI.

For example, a person can assign a support ticket through the UI or ask the
agent to do it. Both paths run the same action and update the same ticket. The
person can inspect or change the result in the UI, then let the agent continue
from there.

## When should you use Agent-Native?

Agent-Native is a good fit when:

- The agent should do real work, not only answer questions.
- People need a UI to see what the agent can do and to inspect, edit, approve,
  or share its work.
- People should be able to move between the agent and UI without losing
  progress or context.

If you only need a single generated response, call a model directly. If the work
follows a fixed, predictable sequence, ordinary application logic or automation
is simpler. Use Agent-Native when the agent and UI both need an ongoing role in
the same work.

## Next steps

<Cards>

### [Getting Started](/docs/getting-started)

Create an agent with a UI and call the same action from the agent and UI.

### [Key Concepts](/docs/key-concepts)

Learn how actions, SQL data, application context, access, and live sync fit
together.

### [Agent Surfaces](/docs/agent-surfaces)

See how agents work through a UI, chat, automation, or another agent.

### [Templates](/docs/cloneable-saas)

Start from a complete open-source agent with a UI instead of starting from
scratch.

</Cards>