> ## Documentation Index
> Fetch the complete documentation index at: https://docs.karta.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Karta

> Deploy an agent defined for a supported harness as durable kartas with sessions, releases, identity, budgets, webhooks, and audit controls.

Karta runs harness-native agent projects in production.

Bring an agent defined to run in a [supported harness](/build/supported-harnesses):
instructions, skills, tools, sub-agents, hooks, and config. Karta packages that
project as a release, serves it through stable APIs and widgets, and creates
durable kartas for the users, virtual employees, backend jobs, or fleet members
that should each have their own workspace and memory.

Use Karta when one agent project needs to create many agent instances: one per
user for personal AI assistant use cases, one per team virtual employee, one
singleton for a backend task, or one per fleet member. Karta adds release
control, metering, budgets, webhooks, audit, and rollback around those
instances.

<CardGroup cols={2}>
  <Card title="Choose your path" icon="signs-post" href="/journeys">
    Pick the right route for first deploys, widgets, API integrations,
    operations, and enterprise review.
  </Card>

  <Card title="Quickstart" icon="bolt" href="/quickstart">
    Deploy a starter or existing agent project in under 10 minutes.
  </Card>

  <Card title="Core concepts" icon="diagram-project" href="/concepts/overview">
    Agents, kartas, sessions, sub-agents, streaming, and releases.
  </Card>

  <Card title="Deploy" icon="rocket" href="/deploy/deploy-loop">
    The ship, serve, consume loop, releases, and rollback.
  </Card>

  <Card title="API reference" icon="code" href="/api-reference/introduction">
    `/v1` sessions, streaming, and OpenAI- and Anthropic-shaped adapters.
  </Card>
</CardGroup>

## Start by job

<CardGroup cols={3}>
  <Card title="I want my first deploy" icon="rocket" href="/quickstart">
    Install the CLI, scaffold an agent, deploy it, and open the hosted chat page.
  </Card>

  <Card title="I already have an agent project" icon="folder-tree" href="/build/agent-structure">
    Keep your harness-native files and add the Karta deploy manifest.
  </Card>

  <Card title="I need a chat widget" icon="window" href="/sdks/widget/quickstart">
    Add the hosted widget, then layer on identity, commands, and theming.
  </Card>

  <Card title="I need an API integration" icon="code" href="/api-reference/introduction">
    Use sessions and messages directly, or choose an OpenAI or Anthropic adapter.
  </Card>

  <Card title="I need production review" icon="shield-halved" href="/security/architecture-review">
    Review architecture, security, spend controls, audit, and operations.
  </Card>

  <Card title="I need to operate agents" icon="gauge" href="/platform/production-readiness">
    Manage releases, sessions, logs, budgets, webhooks, billing, and audit.
  </Card>
</CardGroup>

## What Karta standardizes

| Job                     | Public surface                                                                      | Start with                                                      |
| ----------------------- | ----------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| Create an agent project | `karta create`, `karta setup`, `karta.toml`                                         | [Quickstart](/quickstart)                                       |
| Deploy and roll back    | `karta deploy`, `git push karta`, release activation, rollback                      | [Deploy loop](/deploy/deploy-loop)                              |
| Serve users             | Hosted widget, session tokens, `/sessions`, `/messages`                             | [Choose your path](/journeys)                                   |
| Operate production      | API keys, usage, budgets, billing, webhooks, audit, logs                            | [Production readiness](/platform/production-readiness)          |
| Review security         | Runtime/management boundary, short-lived browser credentials, BYOK, trust materials | [Production architecture review](/security/architecture-review) |

One deploy creates a versioned release and serves it through stable consumer
surfaces:

```text theme={null}
agent project
  |  karta deploy or git push karta
  v
immutable release
  |  active release pointer
  v
hosted agent endpoint
  |  widget, session token, API key, or adapter client
  v
session in the right durable karta
```

Each session resolves to the durable karta you choose: one per user, one per
virtual employee that works with a team, one per backend job, or one per fleet
member. That id decides which agent instance, workspace, and memory the session
uses. See [Kartas & memory](/concepts/instances-and-memory).

## Harness-defined agents

Teams usually choose one of two agent shapes.

Framework-based agents use application code to control the workflow. LangGraph,
CrewAI, AutoGen, and the OpenAI Agents SDK help programmers define state,
routing, tool calls, and control flow.

Harness-defined agents use natural-language instructions, skills, sub-agents,
tools, and MCP configuration to give the model room to plan each turn
dynamically. The harness runs that loop. Karta is built for this second shape:
bring an agent defined for a [supported harness](/build/supported-harnesses),
and Karta adds releases, durable kartas, sessions, identity, budgets, webhooks,
and audit around it.

<Columns cols={2}>
  <Card title="Framework-based agent" icon="screwdriver-wrench">
    Programmer-controlled workflow: code owns state, routing, and the order of
    operations.
  </Card>

  <Card title="Harness-defined agent" icon="layer-group">
    Model-planned workflow: instructions and harness context guide the agent as
    it adapts to each task.
  </Card>
</Columns>

## What you get

<CardGroup cols={3}>
  <Card title="Multi-user sessions" icon="users">
    Route conversations by metadata; multiple humans and AIs in one session,
    each message attributed to its sender.
  </Card>

  <Card title="Streaming-first" icon="wave-pulse">
    HTTP, CLI, SDK, and widget calls share typed events: text, tool use,
    reasoning, approval prompts, errors, and done.
  </Card>

  <Card title="Durable kartas" icon="building">
    Persistent workspace and memory for each user-facing agent, virtual
    employee, backend job, or fleet member. Each karta is its own agent
    instance.
  </Card>

  <Card title="Metering & budgets" icon="gauge">
    Per-org token and cost caps with precise usage tracking. Hit a cap and the
    API returns `402` before running anything.
  </Card>

  <Card title="BYOK" icon="key">
    Bring your own provider key (Anthropic, OpenAI, Bedrock, Vertex,
    OpenRouter), encrypted at rest.
  </Card>

  <Card title="Deploy & rollback" icon="code-branch">
    Immutable versioned releases. Activation and rollback move the active
    release pointer.
  </Card>
</CardGroup>

## Two planes

Karta separates **running your agents** from **managing your account** - the
boundary security and platform teams should verify before launch:

<Columns cols={2}>
  <Card title="Data plane - runs your agents" icon="server">
    The request path: sessions, harness execution in isolated per-session
    sandboxes, release serving, streaming, and request-time budget enforcement.
  </Card>

  <Card title="Control plane - manages your account" icon="shield-halved">
    The system of record: identity, team membership and roles, API keys, usage
    metering and budgets, billing, BYOK keys, outbound webhooks, and the audit log.
  </Card>
</Columns>

The split is the central design decision: **the plane that runs agent code holds
none of your money-and-identity state.** A compromise of a running agent cannot by
itself reach your billing, your team's credentials, or another tenant's data. See
[How Karta works](/concepts/how-karta-works).

## Who Karta is for

<CardGroup cols={3}>
  <Card title="Agent developers" icon="user-gear">
    Author an agent project in your own repo and harness, then deploy it on
    Karta using the dashboard, the `karta` CLI, the SDKs, and your own backend.
  </Card>

  <Card title="Product engineers" icon="window">
    Embed agents in your app with the hosted widget, a custom UI, or an API
    integration that keeps browser credentials short-lived and scoped.
  </Card>

  <Card title="Platform architects" icon="shield-halved">
    Review the trust boundary, isolation model, identity, spend gates, releases,
    webhooks, audit, and operational controls before launch.
  </Card>

  <Card title="DevOps" icon="gears">
    Deploy, configure, and operate agents on Karta - releases, rollbacks, keys,
    webhooks, and live-session debugging.
  </Card>

  <Card title="Admins" icon="chart-line">
    Track usage and cost, set budgets and thresholds, and manage billing for the
    agents you run.
  </Card>
</CardGroup>

Your end users can reach the agent through your hosted widget, your custom UI,
or your backend. Browsers receive publishable widget keys or short-lived
[session tokens](/security/session-tokens), never long-lived API keys.

## Where to go next

<CardGroup cols={2}>
  <Card title="Choose your path" icon="signs-post" href="/journeys">
    Route yourself by job: first agent, existing project, widget, API, ops, or
    architecture review.
  </Card>

  <Card title="Build your first response" icon="bolt" href="/quickstart">
    Install, scaffold or select a folder, deploy, and open the hosted page.
  </Card>

  <Card title="Understand the model" icon="book" href="/concepts/overview">
    The vocabulary the rest of the docs assume.
  </Card>

  <Card title="Author an agent" icon="folder-tree" href="/build/agent-structure">
    Agent layout, sub-agents, skills, and `karta.toml`.
  </Card>

  <Card title="Run a support bot locally" icon="mug-hot" href="/tutorials/support-bot">
    A complete end-to-end walkthrough.
  </Card>

  <Card title="Production readiness" icon="gauge" href="/platform/production-readiness">
    Launch checklist for access, spend controls, releases, webhooks, audit, and support.
  </Card>

  <Card title="Production architecture review" icon="shield-halved" href="/security/architecture-review">
    The enterprise path through security, tenancy, credentials, spend controls,
    webhooks, and audit.
  </Card>
</CardGroup>