Where agents run

Pick it under Where it runs on the plan, in the Runs in row.

Running agents in Layrcake is offered only where it is switched on for your workspace. Elsewhere the Runs in row shows it as COMING, and you pick where you run it.

The Agents page also shows Where your agents run: each place an agent's key reported it was used, labelled as reported.

An agent that runs in Layrcake thinks with a model you choose, and its thinking is charged in Layrcake credits by default. The plan asks “Which model should your agent think with?”

Each choice shows about how many credits of thinking a typical run uses. Per-token prices are on Credits & pricing. An agent that runs in Claude Code, Codex or n8n uses the model you already use there; Layrcake charges only for the tools it calls.

An agent that runs in Layrcake runs on its schedule. Set it under Where it runs: the days, the time, the time zone, and what happens if a run is missed (skip it, or run it once if under 30 minutes late). The plan says it back in words. Go live shows the next run as its first run.

• A run never starts while the last one is still going.
• In a clock change, a missing hour is skipped and a repeated one runs once.
• Pause, resume, change or remove the schedule from the same place.

Run now runs a live agent once, straight away. It is on the agent's card and in the builder. The confirm says the budget: “Runs once now, up to N credits; nothing is sent without your approval.” One run at a time: while one is queued or running, Run now says so and waits.

A run in Layrcake stops at the launch preview. The launch comes to Approvals for your yes. Choose Runs on an agent's card to see what it did: when each run started, what kind it was, how it stands, the credits it used of its budget and the launch it asked you to approve. A run's detail shows each step. Layrcake keeps what each step did, never the model's own words, for 90 days.

Open in Claude Code on an agent's card gives the steps, each with a line to copy. The key is never in them: the command reads it from your shell.

1. Put the agent's key (shown once at Go live) in your shell.
2. Add Layrcake to Claude Code.
3. Download Export, unzip it, and copy the agent's skill folder into your project's .claude/skills/ folder (or ~/.claude/skills/ for every project).
4. Start Claude Code and ask it to run the agent.

export LAYRCAKE_API_KEY="<your key>"
claude mcp add --transport http layrcake https://mcp.layrcake.dev/mcp --header "Authorization: Bearer ${LAYRCAKE_API_KEY}"

Export

Export downloads a zip for Claude Code, Codex or any agent that reads skills or AGENTS.md:

The key is never in the export. Anything in the plan's words that looks like a Layrcake key is removed.

Create from export

Create from export on the Agents page takes the zip, or just its agent.json, and makes a copy as a new draft. It never makes a live agent or changes an existing one: test the copy, then put it live. A file that was edited so it no longer matches its plan, or that would break a rule every agent keeps (like weakening approvals), is refused and nothing is created.

When an MCP client connects with an agent's own key, Layrcake sends it the agent's instructions: its name and job, its plan and Also lines, and the rules that always hold. They are the same words as the export's SKILL.md and AGENTS.md, written from the version the agent runs.

The rules that always hold:

• Spend at most the run's budget. Preview a paid step first and stop before going over.
• Never send on its own. Build the campaign as a draft, ask with launch_campaign, show the approval link and stop.
• Call get_me first, to see what the key may do today.
• Never ask for, print or store the key.
• When a tool refuses, say why in one line and stop that step. Don't look for a way around it.

For an agent outside Layrcake they also say how to start and end a run, below. The instructions are built from the plan alone: no person, key or run result is in them.

An agent in Claude Code, Codex, n8n or a script keeps to its per-run budget by starting a run with its own key and sending the run's id on each call.

curl -X POST https://api.layrcake.dev/v1/agent/runs \
  -H "Authorization: Bearer $LAYRCAKE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

{ "run": { "run_id": "…", "agent_id": "…", "version": 3, "kind": "live", "state": "running",
           "budget": "150", "actual": null, "started_at": "…", "ended_at": null, … },
  "header": "X-Layrcake-Run" }

1. Start a run: POST /v1/agent/runs with the body {}. The run uses the version the agent runs and its budget.
2. Send X-Layrcake-Run: <run_id> on every Layrcake call of the run, over REST or MCP.
3. End it when the work is done: POST /v1/agent/runs/<run_id>/end with the body {}.

The exported .mcp.json and Codex config already send the header from the LAYRCAKE_RUN_ID environment variable. Set it before you start a session and every call in it counts against that run. Without it, the agent's instructions tell it to start its own run. Several runs can be open at once, one per session.

A call with no run header works as any key's call does. To require a run for every paid call, tighten the key with autonomous_action_limits.require_run: true through PATCH /v1/keys/:id (a control:manage key; see Restrict). Turning it off again is a loosening, so only an owner can.