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

# Quickstart

> Run Carry locally — from clone to a live, proof-carrying agent in a few minutes.

This guide takes you from zero to a running Carry: teach a fact, recall it across models, watch the gate block a revoked namespace, and verify a proof on-chain.

## Prerequisites

<CardGroup cols={2}>
  <Card title="Node.js 20+" icon="node-js">
    The app is a Next.js 16 monorepo using npm workspaces.
  </Card>

  <Card title="Sui CLI (for on-chain)" icon="terminal">
    Testnet address with a little SUI — used to anchor proofs locally and to build/publish the Move contract.
  </Card>
</CardGroup>

<Note>
  Carry is **mock-first**: real OpenAI / Anthropic / Walrus adapters sit behind interfaces, and the system falls back to deterministic mocks when a key is absent — so it runs offline and a demo never hard-fails on a flaky testnet.
</Note>

## 1. Clone and install

```bash theme={null}
git clone https://github.com/Enoch208/carry
cd carry
npm install
```

## 2. Configure environment

Copy the example env and fill in what you have. With **no keys**, Carry runs in mock mode; with keys, it runs live.

```bash theme={null}
cp apps/web/.env.example apps/web/.env.local
```

<CodeGroup>
  ```bash Live mode theme={null}
  # apps/web/.env.local
  OPENAI_API_KEY=sk-...
  ANTHROPIC_API_KEY=sk-ant-...
  WALRUS_PUBLISHER=https://publisher.walrus-testnet.walrus.space
  WALRUS_AGGREGATOR=https://aggregator.walrus-testnet.walrus.space
  CARRY_MODE=live
  ```

  ```bash Mock mode theme={null}
  # apps/web/.env.local
  CARRY_MODE=mock
  # no API keys needed — deterministic stubs for LLM + Walrus
  ```
</CodeGroup>

<Tip>
  The on-chain config (package + policy IDs) is read from `deployments/testnet.json`, so you don't need to set it manually to use the public verifier.
</Tip>

## 3. Run the app

```bash theme={null}
npm run dev
```

Open [http://localhost:3000](http://localhost:3000).

## 4. The five-minute tour

<Steps>
  <Step title="Teach a fact">
    Open **Chat A** (GPT-4o). Use the capture box to store a fact in the `health` namespace — e.g. *"Allergic to penicillin."* It's written to Walrus as a real blob.
  </Step>

  <Step title="Recall across models">
    Open **Chat B** (Claude). Ask *"Am I allergic to anything?"* Agent B — a different provider — recalls the fact and renders an **Answer Receipt** showing the memory used, that it was authorized, and that the blob still resolves on Walrus.
  </Step>

  <Step title="Revoke and watch the gate">
    Open **Access** and revoke Agent B's access to `health`. Ask again — the agent truthfully refuses, and the receipt shows `health blocked by policy`. The gate ran **before** the model, so the memory was never fetched.
  </Step>

  <Step title="Anchor and verify">
    Under any Answer Receipt — in **Aria** (`/companion`) or the Dashboard — click **Anchor on Sui**. Carry mints a tamper-evident `Receipt` object (signed server-side, no wallet) and hands back a `/verify/<id>` link. Open it and watch three independent checks go green against Sui and Walrus.
  </Step>
</Steps>

## 5. Run the tests

```bash theme={null}
npm test                      # TypeScript: core gate, receipts, digest, verify
cd contracts && sui move test # Move: receipt minting, hash chain, blake2b256
```

## Next steps

<CardGroup cols={2}>
  <Card title="Architecture" icon="diagram-project" href="/architecture">
    See how the gate, Walrus, and on-chain proof fit together.
  </Card>

  <Card title="Use it from any agent" icon="plug" href="/integrate/mcp">
    Wire Carry into Cursor, Claude Desktop, or Claude Code via MCP.
  </Card>
</CardGroup>