How many runs does compiling have to pay back?

Compiling costs 50 and a replay costs 1, against 10 to re-reason each time. Compiling wins once the saving (9 credits a run) exceeds the compile — the breakeven arithmetic and the exact run number are computed on the pricing page from the same constants.

What happens when the site changes and the compiled path breaks?

A replay that drifts is detected rather than silently wrong, and the platform re-compiles or repairs the path rather than replaying a step that no longer means anything. That is a cost event, not a failure: you pay for the recompile once and go back to cheap replays.

Core tool

Solve a task once, keep the minimal path

Runs the planner against a live target, then minimizes the verified action path into a named, versioned skill that later replays with no model in the loop.

Get an API key MCP setup

compile_skill

What it is

The job: Turn a flow you are going to run many times into a stored artifact that costs almost nothing to run again.

Compiling is a real run. The planner discovers the flow against the live site, and only a run that actually reached the goal produces a path — there is no separate verification pass, because a compile that did not succeed has nothing to store. The path is then minimized: steps that turned out not to matter are dropped, so what is stored is the shortest sequence that still reaches the goal.

The result is a named, versioned skill scoped to your tenant. From then on run_skill replays it with no LLM call at all, and dispatch can fuzzy-match a re-phrased request onto it. Compilation is the expensive half of the flywheel and replay is the cheap half; the arithmetic is on the pricing page and it is not close after a handful of runs.

Skills are also where parameters live. A compiled path keeps {{param:NAME}} tokens rather than freezing the values used at compile time, so one skill covers every future invocation of the same shape.

The call

Call it exactly like this.

Copied from the tool's registration and the route handler — not paraphrased.

MCPcompile_skill.mcp.jsonjson

// MCP tool call — server "twin-browser"
{
  "tool": "compile_skill",
  "arguments": {
    "target": "https://app.example.com",
    "goal": "login",
    "name": "acme-login"
  }
}

POST /api/v1/skillsrequest.shbash

curl -X POST https://twin-browser.com/api/v1/skills \
  -H "Authorization: Bearer $TWIN_API_KEY" \
  -H "content-type: application/json" \
  -d '{"target":"https://app.example.com","goal":"login","as":"acme-login"}'

The MCP tool exposes only the NAMED form ({ target, goal }), so through MCP you compile one of the registry goals. The REST endpoint additionally accepts the ad-hoc form — { url, prompt, success, as } — which is what lets you compile an arbitrary flow on an arbitrary site. Use dispatch from MCP to get the same effect: a cache miss compiles and stores the skill for you.

Parameters accepted by compile_skill
Parameter	Type	What it does
target*	string	Base URL of the target to compile against. The compile runs for real against this site.
goal*	string	The registry goal name to compile. (REST also accepts url + prompt + success instead.)
name	string	Optional skill name — sent as `as` on the REST body. Defaults to the goal name.

Returns

response.jsonjson

{
  "name": "acme-login",
  "version": 1,
  "target": "https://app.example.com",
  "steps": 6,
  "runId": "…",
  "credits_charged": 50
}

What it costs

50 credits

A 50-credit floor, settled higher-of against the metered model cost — compiling is the most model-heavy call on the platform because it is a full discovery run plus a minimization pass. A compile that fails to reach the goal is refunded in full: there is nothing to store, so there is nothing to charge for.

See the full rate card

Which one

When a different tool is the right call.

The honest answer is often the neighbouring tool. These are the trades.

dispatch

dispatch compiles for you on a cache miss, and caches the result. If you do not care about naming the skill yourself, dispatch is strictly less work. compile_skill is the explicit path when you want a known name to call by.

dispatch

run_goal

run_goal is cheaper for a single run and more expensive for every run after the sixth or so. If you are not going to run the flow again, do not compile it.

run_goal

Questions

compile_skill, answered.

How many runs does compiling have to pay back?: Compiling costs 50 and a replay costs 1, against 10 to re-reason each time. Compiling wins once the saving (9 credits a run) exceeds the compile — the breakeven arithmetic and the exact run number are computed on the pricing page from the same constants.
What happens when the site changes and the compiled path breaks?: A replay that drifts is detected rather than silently wrong, and the platform re-compiles or repairs the path rather than replaying a step that no longer means anything. That is a cost event, not a failure: you pay for the recompile once and go back to cheap replays.

Keep going

The rest of the tool set.

run_skill

Run a known-good flow again, as cheaply as it can possibly be run.

dispatch

Be the one call an agent makes, and get cheaper every time the agent asks for the same thing in different words.

list_skills

Answer “what do I already have?” before spending anything.

list_catalog

Let an agent plan: pick a skill it can actually run, with values it can actually supply.

The mechanism behind it:Deterministic replay Skill library Semantic dispatch cache

Get an API key All tools