rote is a command line tool that compiles a proven AI agent skill into a deterministic pipeline. The parts that can be plain code become plain code, and the LLM is kept only for steps where judgment is genuinely required.

Yes. rote is open source under the Apache 2.0 license and ships on PyPI as rote-cli. You can run it today with uvx and never touch the waitlist.

Which runtimes can it target?

Six today: DBOS in Python as the default, Temporal, Cloudflare Workflows, DBOS TypeScript, Inngest, and a plain Python adapter with no engine at all. Restate support is planned.

Does it replace Temporal or my agent framework?

No. Engines like Temporal and DBOS are compile targets, not competitors. rote decides what should even be a workflow, generates the pipeline, and emits code for the engine you already operate.

When should I keep using an agent loop?

For exploratory and one off work. Flexibility is the whole point there. rote is for skills that have become business critical and need to run unattended with reliability guarantees and regression tests.

What does joining the waitlist get me?

Release announcements only. We will email you as new runtimes and major releases land. No spam.

rote · open source from Vaib Studio

Use AI for what it's good at. Deterministic, durable, cheap to run.

rote takes an agent skill you already trust and graduates it into a real workflow. Everything provable becomes plain code. The LLM stays only where judgment is genuinely required.

Join the Waitlist View on GitHub →

✓ Apache 2.0✓ On PyPI today✓ Six runtime targets

# graduate a skill into a durable pipeline

$ uvx --from rote-cli rote graduate ./my-skill --out ./graduated/

# re emit the same pipeline to another runtime

$ uvx --from rote-cli rote emit ./graduated --runtime temporal

Why compile a skill

Agent loops are great to build. They are rough to operate.

rote fixes all three problems the way a compiler would: it moves the deterministic parts into code and keeps the model only where inputs are truly open ended.

Slow

A fuzzy skill run takes ten to twenty minutes of agent time, every single time.

Expensive

You pay full model tokens on every run, even for steps that never change.

Nondeterministic

The same input can produce a different path tomorrow. That is hard to test and harder to trust.

How it works

From SKILL.md to a pipeline you can regression test.

Point rote at a skill

A SKILL.md and its references folder is all it needs. The same format your agents already use.

The graduator classifies every step

An LLM reads the skill against a structured rubric and sorts each step into one of five node kinds by how deterministic it can be.

Emit to your runtime

One pipeline.yaml plus generated code for the engine you already operate. Emission is plain code and byte identical every time, so you can regression test it.

Five node kinds

One honest question for every step: does this need a model?

Each answer becomes a node with the cheapest implementation that still does the job.

pure_function

Provable logic becomes plain Python. Deterministic, testable, free to run.

external_call

API and tool calls with typed inputs and outputs, handled by your runtime's retries.

llm_judge

A single model call behind a typed signature, kept only where inputs are genuinely unbounded.

agent_loop

A bounded agent loop, preserved only for steps that truly need exploration.

hitl_gate

A human approval gate that durably suspends the pipeline and resumes when you say so.

Runtime targets

Write once, run on the engine you already trust.

The intermediate representation is independent of any runtime. Emit the same pipeline to any of six targets today, with Restate planned.

DBOS

Python, the default. SQLite in dev, Postgres in prod, no orchestrator to run.

Temporal

Python workers for teams already on Temporal.

Cloudflare Workflows

TypeScript at the edge.

DBOS TypeScript

The DBOS model for TypeScript stacks.

Inngest

TypeScript, event driven.

Plain Python

A raw adapter with no engine at all.

The research behind the idea

Compiled pipelines are not a hunch.

rote builds on Compiled AI, a 2026 paper by Trooskens et al. on compiling LLM workflows into deterministic pipelines. Their measurements, not ours: 57x fewer tokens, 450x lower median latency, and 100 percent reproducibility.

57x

fewer tokens than running the agent loop

450x

lower median latency

100%

reproducibility, versus 95% at temperature zero

rote's own bundled example graduates a real sales outreach skill into a 22 node pipeline, 78.9 percent plain code, in about 13 minutes for about $0.70. It also caught three mandatory exclusion checks the human baseline missed.

Exploration stays an agent

One off tasks and open ended research need flexibility. Keep those as live agent loops.

Graduation is for proven skills

rote shines on the skill you have already run twenty times and now want to run a thousand more, unattended.

Humans stay in the loop where it matters

Approval gates are a first class node kind. The pipeline durably pauses until someone signs off.

Claude Code plugin

Lives where your skills live.

Add the marketplace inside Claude Code, then ask Claude to graduate a skill in plain language. A second skill serves your graduated pipelines as MCP tools, so agents can call them like any other tool.

# inside Claude Code

$ /plugin marketplace add trevhud/rote

Questions engineers ask

Honest answers, no fine print.

What is rote?: rote is a command line tool that compiles a proven AI agent skill into a deterministic pipeline. The parts that can be plain code become plain code, and the LLM is kept only for steps where judgment is genuinely required.
Is rote free?: Yes. rote is open source under the Apache 2.0 license and ships on PyPI as rote-cli. You can run it today with uvx and never touch the waitlist.
Which runtimes can it target?: Six today: DBOS in Python as the default, Temporal, Cloudflare Workflows, DBOS TypeScript, Inngest, and a plain Python adapter with no engine at all. Restate support is planned.
Does it replace Temporal or my agent framework?: No. Engines like Temporal and DBOS are compile targets, not competitors. rote decides what should even be a workflow, generates the pipeline, and emits code for the engine you already operate.
When should I keep using an agent loop?: For exploratory and one off work. Flexibility is the whole point there. rote is for skills that have become business critical and need to run unattended with reliability guarantees and regression tests.
What does joining the waitlist get me?: Release announcements only. We will email you as new runtimes and major releases land. No spam.

Follow rote to 1.0.

rote is early and moving fast. Join the waitlist and we will let you know as new runtimes and major releases land.

Prefer to dive in now? rote-cli is on PyPI and the source is on GitHub.

Loading page...