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

# What is asymmetric?

> Real, disposable SaaS clones to build and evaluate AI agents against.

AI agents act on real systems. They send Slack messages, close issues, refund
payments, and update records. That makes them hard to test: a live workspace is
risky and non-deterministic, and a pile of mocks is never faithful enough to
trust the result.

**asymmetric** gives you the middle ground. It spins up real, running clones of
SaaS products on your machine in seconds — each a full backend with a Postgres
database, the product's real HTTP API, real auth, and an MCP server. Close enough
to the real product that an agent can't tell the difference. Disposable enough
that you throw it away and spin a fresh one for the next run.

Six templates ship today — **Slack, Stripe, Notion, HubSpot, GitHub, and
Linear** — each cloned to match the real product's API and MCP surface.

If you build or evaluate agents, asymmetric is the safe, reproducible place to
point them.

<CardGroup cols={2}>
  <Card title="Spin your first clone" icon="rocket" href="/quickstart">
    Nothing to a running, seeded clone in five minutes.
  </Card>

  <Card title="See how it works" icon="diagram-project" href="/concepts/how-it-works">
    The architecture behind a clone, in one diagram.
  </Card>

  <Card title="Connect your agent" icon="plug" href="/guides/connect-agent">
    Point your agent at a clone over its HTTP API or MCP.
  </Card>

  <Card title="Browse the CLI" icon="terminal" href="/cli/overview">
    Every command and flag, with real output.
  </Card>
</CardGroup>

## The mental model

asymmetric has two nouns, at two altitudes.

<CardGroup cols={2}>
  <Card title="Clone" icon="copy" href="/concepts/clones">
    One running instance of a SaaS product — a real backend, its own database,
    real auth. The unit you build and compose.
  </Card>

  <Card title="Environment" icon="layer-group" href="/concepts/environments">
    A named composition of clones on shared infrastructure. The unit you point an
    agent at and **score**.
  </Card>
</CardGroup>

A clone is faithful enough that your agent operates it like the real thing.
An environment is the thing your eval runs against — today one clone, soon
several products sharing one identity graph.

## The loop

Every asymmetric session is the same five beats. Each is one command.

<Steps>
  <Step title="Spin">
    `asym spin slack` creates a clone, allocates ports, runs migrations,
    and waits until it's healthy. You get a live API endpoint back.
  </Step>

  <Step title="Seed">
    Load a deterministic fixture for repeatable evals, or generate realistic data
    with an LLM. Either leaves the clone in a known starting state.
  </Step>

  <Step title="Run">
    Point your agent at the clone's HTTP API or MCP server. It reads, writes, and
    acts against a real backend — every action lands in the clone's own database.
  </Step>

  <Step title="Inspect">
    Read the database directly with `query` to score exactly what the agent did.
    Stream `logs` to debug.
  </Step>

  <Step title="Reset or destroy">
    `reset` drops and re-seeds to the same starting state for the next trial.
    `destroy` tears it down and frees the ports.
  </Step>
</Steps>

## Why a clone, not a mock

<CardGroup cols={2}>
  <Card title="High fidelity, not stubs" icon="layer-group">
    Clones are real NestJS backends on real Postgres with real JWT auth — stateful,
    referentially consistent, returning authentic errors. Not canned responses.
  </Card>

  <Card title="Reproducible to the row" icon="rotate">
    Every clone has a stable id, its own database, and a recorded seed. `reset`
    rebuilds it to byte-for-byte the same starting state.
  </Card>

  <Card title="Scorable" icon="magnifying-glass-chart">
    The agent's work is just rows in a database you own. Read them with `query`
    to grade a run objectively, not by scraping output.
  </Card>

  <Card title="Local-first" icon="laptop">
    Everything runs through Docker on your machine. No cloud account, no external
    dependencies. A connected control-plane mode is planned.
  </Card>
</CardGroup>

## Concepts at a glance

| Term            | What it is                                                                                                                                                                                       |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Clone**       | One running instance of a template — a real backend with its own database, auth, and ports. You pass its **id** (`slack-a1b2`) to every command.                                                 |
| **Environment** | A named composition of clones you point an agent at and score. Membership is the single source of truth; clones don't know which environment they're in.                                         |
| **Template**    | A directory with a `clone.manifest.json` that declares how a product is cloned — services, modes, migrations, seeds. Six ship today: `slack`, `stripe`, `notion`, `hubspot`, `github`, `linear`. |
| **Mode**        | A named set of a template's services (`api` = backend only, `full` = backend + frontend).                                                                                                        |
| **Seed**        | The data loaded into a fresh clone — a deterministic **fixture** or **AI**-generated data. Replayed on `reset`.                                                                                  |
| **Provider**    | The engine behind every command. `LocalDockerProvider` today; a `CloudProvider` is planned. Same commands, different engine.                                                                     |
| **Registry**    | `~/.asymmetric/registry.json` — the source of truth recording every clone and environment.                                                                                                       |

## What's in the box

| Piece               | Package                                                           | What it is                                                                                                            |
| ------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| The CLI             | `apps/cli` (`@asymmetric-ai/cli`, commands `asym` / `asymmetric`) | The `spin → seed → inspect → reset` toolchain you drive.                                                              |
| The contract        | `packages/clone-contract`                                         | The shared `CloneProvider` interface, types, and named errors — the seam everything is built against.                 |
| The clone templates | `apps/*-clone`                                                    | Six templates today — Slack, Stripe, Notion, HubSpot, GitHub, Linear — each a real backend, MCP server, and Postgres. |

## Next steps

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Spin, seed, and point an agent at your first clone.
  </Card>

  <Card title="How it works" icon="diagram-project" href="/concepts/how-it-works">
    CLI, contract, providers, shared infra, and templates.
  </Card>

  <Card title="Connect your agent" icon="plug" href="/guides/connect-agent">
    HTTP API and MCP, with working examples.
  </Card>

  <Card title="Available templates" icon="layer-group" href="/templates/slack">
    The clones you can spin today.
  </Card>
</CardGroup>