examples

Start with one step. Add a loop. Then explore the larger patterns when you need them. Every interactive example uses the real compiler and runner in your browser.

10 seconds Hello, world

One stage and one automatic next step.

2 minutes Issues to PRs

A small work queue with progress and a loop.

Go deeper Checkout revamp

Retry limits, gates and human decisions.

Hello, world

This is the smallest useful plan: do one piece of work, then finish. The line -> END means “when this stage is done, complete the plan automatically.” Edit the task or press the only route on the right.

hello-world.mar

rationale

Turn issues into pull requests

A compact agent workflow: pick an issue, update its status, implement it, open a pull request, and repeat. The number of ready issues is supplied at runtime: the loop works through that count, then checks the queue again instead of paying for another lookup after every issue.

Read it from top to bottom

VAR remaining: number = ? asks for the initial count. while continues while that count is non-zero. The optional “Check for newly ready issues” label clarifies the next action for the agent; the loop itself controls when that route is available.

issue-loop.mar

rationale

Add limits and human decisions

The checkout plan allows up to five evidence-driven attempts. A person decides whether to launch, rethink, or stop. Select “Cohort converts” to see the runner refuse a route marked @human.

checkout.mar

# project: checkout-revamp
# prompt: """
Checkout conversion has been flat for two quarters. Rebuild the flow
behind a flag and iterate on cohort evidence — five attempts max. I take
the ship call, and if it never converts we go back to research rather
than grinding out attempt six.
"""
# github:repo: acme/shop
# ref: https://wiki.acme.dev/checkout-revamp
VAR attempts = 0

=== build_checkout ===
# github:issue: 41
Rebuild the checkout flow behind a feature flag.
Ship one measurable change per attempt to the flag cohort and read the
conversion funnel after a full week; an attempt is done when its data is in.
~ attempts += 1
* [Cohort converts] @human -> rollout
+ {attempts < 5} [Conversion flat — iterate] ~loop~ -> build_checkout
* {attempts >= 5} [Not converging — rethink] @human -> rethink

=== rethink ===
# ref: https://wiki.acme.dev/checkout-usability-study
Five iterations without lift: take the flow back to research.
Run the checkout usability study and write up why the five attempts failed;
that write-up is the input to whichever door is taken next.
+ [New direction agreed] @human ~loop~ -> build_checkout
* [Park the revamp] @human -> END

=== rollout ===
# github:issue: 42
Ramp the flag to 100% and retire the old flow.
Watch error rates and conversion during the ramp; done means the old flow is
deleted, not merely dark.
-> END

rationale

A real project: this documentation site

An agent built the site by following a Marionette plan: capture the real CLI, write the content, build the interactive demos, check accessibility, then stop for human review. The full plan is intentionally detailed; use it when you want to see how a real delivery project records its gates and rework loops.

Stress test: an 18-stage replatform

This production replatform covers shadow traffic, parity checks, SRE and Finance approval, rollback budgets, and freeze-window rebooking. It exists to prove the compiler still gives a clear answer when a plan is much larger than the examples above:

validate --strict — 18 stages, 0 errorsexit 0

$ marionette validate paas_replatform.mar --strict✓ paas_replatform.mar: 0 errors, 0 warnings

Read the full source on GitHub or load it in the home-page playground. It exercises every language feature and the external tracker references.

Patterns exercised by these examples

Human checkpoints: @human prevents an autonomous transition while preserving the choice in the frontier.
Rollback paths: migrations model fallback routes as ordinary graph edges, so validation includes them.
Bounded retries: counters and gates limit loops and expose an explicit exit when the budget is exhausted.
Decision logging: each successful transition records its actor, timestamp and rationale.