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

# What are Hone Environments?

> Real, disposable SaaS clones for reproducing and verifying agent behavior — part of Hone.

**Environments are how [Hone](https://usehone.dev) reproduces and verifies agent
failures.** Hone mines what's breaking from your production traffic; an
environment is where you **reproduce** that failure with one command, **fix** it,
**prove** the fix against a real backend, and **prevent** it from regressing.
Hone Environments began life as the standalone product *asymmetric* — that
product is retired, and its clone engine now ships as this capability of Hone.

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.

**Hone Environments** give you the middle ground. The CLI 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, Hone Environments are the safe, reproducible
place to point them.

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

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

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

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

## The mental model

Hone Environments have two nouns, at two altitudes.

<CardGroup cols={2}>
  <Card title="Clone" icon="copy" href="/environments/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="/environments/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 environment session is the same five beats. Each is one command.

<Steps>
  <Step title="Spin">
    `hone env 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/hone-cli`, bin `hone` — environment commands live under `hone env`) | 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="/environments/quickstart">
    Spin, seed, and point an agent at your first clone.
  </Card>

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

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

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