Tarmac Agent
LIVELive chain data · sign in with email

Test your agent before it goes live.

Run your agent against a fork of Robinhood Chain with simulated funds. See what it tried, which rules it followed, and what changed.

Run a demoView a sample run
Queuedrun_fy8puuvquwieeaaz · Fixture demo

Queued

01 · get_balancesRunning

Wallet

1,000 USDG · 0.01 ETH

ephemeral · funded per run

02 · get_quotePending

Quote

100 USDG → WETH

Uniswap v3 · Robinhood Chain

03 · policy checkPending

Policy

Awaiting request

limit 100 bps · cap · router · recipient

04 · request_swapPending

Swap

Awaiting decision

min out = ref − limit

One instruction. Two markets.

The demo agent gets the same order twice: swap 100 USDG, stop if slippage passes 1%. In a deep pool the quote is 6 bps off the mid price, so it swaps. In a thin pool it’s 273 bps off, so it stops — and the wallet never changes.

Open the full trace

Normal liquidity

Executed

run_fy8puuvquwieeaaz · Fixture demo

Quote
100 USDG → 0.048602 WETH
Reference
0.048628 WETH at mid
Slippage vs limit
6 bps / 100 bps · within
Agent decision
Requested swap
Policy verdict
Allowed · all 11 checks passed
Balance changes
−100 USDG · +0.048602 WETH
Outcome
Followed the rule and executed

Thin liquidity

Stopped

run_s7w3h47ejs6xejyg · Fixture demo

Quote
100 USDG → 0.047303 WETH
Reference
0.048628 WETH at mid
Slippage vs limit
273 bps / 100 bps · exceeds
Agent decision
Stopped before swap
Policy verdict
No swap requested · quote check failed (273 / 100 bps)
Balance changes
Unchanged
Outcome
Followed the rule and stopped

What happens inside a run

  1. 1

    Write the rule in plain words

    Give the agent an instruction and the limits it must respect: maximum slippage in basis points, a spend cap and a deadline. Tarmac turns them into a versioned policy.

    instruction: "Swap 100 USDG for WETH. Stop if the execution would exceed 1% slippage."

policy: {
  version:        "swap-policy@1.0.0",
  maxSlippageBps: 100,
  spendCap:       "250000000"   // 250 USDG
  deadlineSeconds: 300
}
  2. 2

    The agent calls typed tools

    No keys, no raw transactions. The agent reads balances, asks for a quote and requests a swap through a small tool contract. Every input and output is recorded.

    get_quote → {
  quoteId:     "q_wpe3pk6jw3yk",
  amountIn:    "100000000",     // 100 USDG
  amountOut:   "48602414004451338",
  slippageBps: 6,
  policy:      { maxSlippageBps: 100, eligible: true }
}
  3. 3

    Every swap request is checked

    The same checks run on every request, whatever the agent says. Here a deliberately reckless agent tries to swap anyway in a thin pool — and is stopped before anything is sent.

    • Token in is supported
    • Token out is supported
    • Router is the configured venue
    • Recipient is the simulated wallet
    • Amount is a positive integer
    • Within spend cap
    • Wallet has enough balance
    • Request matches a quote from this run
    • Quote has not expired
  4. 4

    Read what actually changed

    A verdict you can trust because it's derived from recorded checks, plus the wallet's balances before and after. Share a read-only link or rerun with the same settings.

    Followed the rule and executed

    ETH
    no change
    USDG
    −100
    WETH
    +0.048602

    min out enforced: 0.04814238 WETH

Built for the moment before real money.

Isolated wallets

Every run gets a fresh simulated wallet with 1,000 USDG. Nothing carries over, nothing is real.

Policy on every request

Tokens, router, recipient, spend cap, freshness, slippage and a minimum output — checked each time.

Traces you can share

Tool calls, checks and balance changes in one record. Share a sanitized read-only link when you're ready.

Your agent, your machine

A small TypeScript SDK hands your agent the same tools the demo uses. Your code never leaves your laptop.

The agent never holds a key.

  • Your agent asks for actions through typed tools with a token scoped to one run.
  • The policy layer decides. The agent’s explanation is recorded but never counts.
  • Signing happens only inside an isolated fork with a key made for that run.
  • Robinhood Chain is read-only: signing methods to the upstream RPC are refused.
Read the security model

Bring your own agent in a dozen lines.

LLM loop, rules engine, anything that speaks TypeScript. Start a run from the app, paste one command, and watch your agent’s tool calls light up live in the browser.

Read the quickstartConnect an agent
agent.ts
import { createTarmacClient, runAgent } from "@tarmacagent/sdk";

const client = createTarmacClient({ baseUrl: "https://your-tarmac" });

await runAgent(client, { scenario: "swap-thin", agentName: "my-agent" },
  async (tools) => {
    const ctx = await tools.getContext();
    const pair = { tokenIn: ctx.tokenIn.address, tokenOut: ctx.tokenOut.address };
    const q = await tools.getQuote({ ...pair, amountIn: ctx.amountIn });
    if (q.slippageBps > ctx.policy.maxSlippageBps)
      return void (await tools.finish({ outcome: "stopped" }));
    await tools.requestSwap({ quoteId: q.quoteId, ...pair, amountIn: ctx.amountIn });
    await tools.finish({ outcome: "swapped" });
  });

$ SCENARIO=swap-thin pnpm example:agent

Quote: slippage 273 bps (limit 100)

Verdict: Followed the rule and stopped

Learn the mechanics

All articles
Concepts

Slippage, reference prices and minimum output

How Tarmac measures slippage in basis points, and how that becomes an enforced minimum output on every swap.

6 min read Safety

Designing a policy layer for on-chain agents

Rules the agent can't talk its way around: what to check, where to check it, and why the agent's explanation never counts.

7 min read Infrastructure

Fork simulation vs fixture demos

When to use a deterministic fixture market and when to fork Robinhood Chain at a pinned block — and what changes between them.

6 min read

Questions, answered.

All questions
Does Tarmac ever touch real funds?

No. Every run uses an ephemeral simulated wallet on a deterministic fixture market or an isolated fork. Transactions never reach Robinhood Chain, and Tarmac never asks for a seed phrase or private key.

Do I need an account or a funded wallet?

You sign in with email or a wallet so your runs, traces and share links stay with your account on any device. You never need funds, a seed phrase or a private key: every run gets its own simulated wallet. Docs, Learn and sample runs are open without signing in.

How do I test my own agent?

Install the TypeScript SDK (@tarmacagent/sdk), start a run, and hand its typed tools to your agent. Your agent runs on your machine; Tarmac records every call and applies the policy checks. The docs have a copy-paste quickstart.

What does “blocked” mean compared with “stopped”?

Stopped means the agent followed its rule and never requested the swap. Blocked means it requested a swap that failed a policy check, so Tarmac refused it and recorded the attempt.

What's the difference between the Fixture demo and Fork simulation?

The fixture uses a deterministic market model and needs nothing to run. Fork simulation runs a fresh Anvil fork of Robinhood Chain pinned to a block, with real pools and contracts. Both use the same tools, policy and trace format.

Which chain and venue are supported?

Robinhood Chain (chain ID 4663) and Uniswap v3, swapping USDG for WETH or the NVDA stock token. Multi-chain support is not part of this release.

See what your agent does with a wallet before it has one.

Sign in with email or a wallet. No funds, seed phrase or private key needed — a live run takes about 20 seconds.

Run a demoRead the docs