Tensile Documentation

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

Environments are how Tensile reproduces and verifies agent failures. Tensile 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. Tensile Environments began life as the standalone product asymmetric — that product is retired, and its clone engine now ships as this capability of Tensile.

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.

Tensile 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, Tensile Environments are the safe, reproducible place to point them.

Spin your first clone

Nothing to a running, seeded clone in five minutes.

See how it works

The architecture behind a clone, in one diagram.

Connect your agent

Point your agent at a clone over its HTTP API or MCP.

Browse the CLI

Every command and flag, with real output.

The mental model

Tensile Environments have two nouns, at two altitudes.

Clone

One running instance of a SaaS product — a real backend, its own database, real auth. The unit you build and compose.

Environment

A named composition of clones on shared infrastructure. The unit you point an agent at and score.

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.

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.
Seed
Load a deterministic fixture for repeatable evals, or generate realistic data with an LLM. Either leaves the clone in a known starting state.
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.
Inspect
Read the database directly with query to score exactly what the agent did. Stream logs to debug.
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.

Why a clone, not a mock

High fidelity, not stubs

Clones are real NestJS backends on real Postgres with real JWT auth — stateful, referentially consistent, returning authentic errors. Not canned responses.

Reproducible to the row

Every clone has a stable id, its own database, and a recorded seed. reset rebuilds it to byte-for-byte the same starting state.

Scorable

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.

Local-first

Everything runs through Docker on your machine. No cloud account, no external dependencies. A connected control-plane mode is planned.

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.