Agents write. Humans review. Machines execute.

Define the process. Agents run it around the clock.

Less rework. Fewer review rounds. Agents that get better without you babysitting them.

Crumbs gives you a language to define it and a machine to run it.

Request access

WHAT CHANGES WITH CRUMBS

Volume without compromise.

codify behavior supervise execution improve continuously

Your process is code. Same rigor applied to the 100th run as the first.
Focused tasks, not mega-prompts. Each agent gets a clear job with explicit boundaries.
The system learns from every run. Patterns emerge. Insights compound.

WHAT YOU WRITE

Crumbs: A language for agent workflows

One file defines what agents do, what they can access, and how work flows.

Syntax

1 Syntax 2 Tasks 3 Capabilities 4 Flow

Syntax

(workflow hello
  in: name string
  out: string

  (task greet
    in: who string
    out: string

    Say hello to the person.
  )

  (do
    (greet who: name)
  )
)

Review it like code. Because it is.

A purpose-built language for humans and agents.

Readable by humans

Structured blocks and plain English intent. You can review a workflow without running it.

Writable by agents

Unambiguous syntax with one way to express each concept. Agents generate it reliably.

Enforced by a compiler

The compiler checks types, contracts, and structure before anything runs. Agents produce better results when the rules are explicit.

Tasks

(workflow feedback_daily
  ...

  (task analyze_feedback
    in: feedback FeedbackBatch
    out: FeedbackSummary

    provider: openai high
    timeout: 10m
    attempts: 3

    Review customer feedback and group
    it into clear themes. Separate
    urgent issues from long-term
    requests. Call out where sentiment
    is strongest. Output a concise
    summary with ranked themes,
    supporting examples, and
    recommended next actions.
  )

  ...
)

One task, one agent, one clear job.

Typed inputs, typed outputs, and plain English intent. Each task is a self-contained unit of work.

Clear contract

The agent knows exactly what it receives and what it must produce.

Intent in plain English

The prose tells the agent what to do and what good output looks like. No ambiguity.

You control execution

Choose the provider, set the timeout, configure retries. You decide how each task runs.

Capabilities

(workflow feedback_daily
  ...

  (workstation my_computer
    (tool fetch_tickets
      out: Ticket list
      command: "fetch_tickets.py"
    )
  )

  (workspace reports path: "/reports")
  (workspace tickets on: my_computer)

  (memory FeedbackPatterns
    schema: FeedbackPattern

    Capture recurring themes and
    edge cases from prior runs.
  )

  (channel TeamUpdates
    provider: slack "#feedback-ops"

    Post blockers, decisions, and
    handoffs for this run.
  )

  ...
)

You decide what agents can reach.

Tools, workspaces, memory, and channels are declared in the workflow. Each task gets only the access you grant.

Built in

No glue code. Capabilities are part of the language and composable out of the box.

Declared in code

Everything an agent can access is visible in the workflow file. Nothing is hidden in config.

Explicit boundaries

An agent can only use what you give it. Nothing more.

Flow

(workflow feedback_daily
  ...

  (do
    (list_teams as: teams)

    (loop for: team in: teams
      as: team_summaries
      out: TeamSummary
      mode: parallel

      (collect_team_feedback
        team: team date: date)
      (analyze_team_feedback
        team: team
        feedback: collect_team_feedback)
    )

    (generate_daily_report
      summaries: team_summaries
      date: date)
    (post_team_update
      report: generate_daily_report)
  )
)

You define the order. The runtime enforces it.

Sequencing, loops, and parallelism are code, not agent decisions. Every run follows the same plan.

Orchestration is explicit

You decide the order, the dependencies, and what runs in parallel.

Agents don't improvise

Crumbs executes the plan as written. Agents follow the flow, they don't decide it.

Improve incrementally

Each run is fully observable. When something falls short, refine the workflow. Future runs inherit the change.

Next: Tasks

WHAT RUNS IT

Crumbs: A hosted OS for you and your agents

One machine runs your workflows, keeps every trace on disk, and gives you one CLI to manage it all.

Machine + CLI

1 Machine + CLI 2 Filesystem 3 Runs 4 Memory

Terminal

❯ crumbs machine create --name development --region ewr --size small

Machine 'development' created.
Region: ewr · Size: small · Status: starting

❯ crumbs machine list

NAME           REGION  SIZE    STATUS    CREATED
operations     iad     large   running   2026-01-15
development    ewr     small   starting  just now

❯ crumbs attach operations --bind tickets:/Users/sarah/tickets

Establishing secure tunnel... ✓ connected

  Machine:  operations (iad · large · running)
  Bound:    tickets ← /Users/sarah/tickets

  Workflows can now access tickets as:
    (workspace tickets on: sarah-mbp)

Press Ctrl+C to disconnect.
[23:07:06] → fs list /home → ok
[23:07:09] → runs list → ok

Hosted machines. One CLI.

Create machines for different workloads. Attach from your terminal to bridge local files with remote workflows.

Your fleet

Spin up machines for operations, development, analytics. Start, stop, and scale independently.

Attach and bind

Connect your computer to a machine. Local folders become workspaces your remote workflows can access.

Same interface, humans and agents

Claude Code, Cursor, any agent with the crumbs binary can run workflows, check results, and manage memory. Same commands you'd type.

crumbs — operations

❯ crumbs fs list /

home  library  memory  queue  runs
scheduler  stats  system  tmp  var
workspaces

❯ crumbs fs list /reports

feedback_daily_20260225.md
feedback_daily_20260226.md
feedback_daily_20260227.md

❯ crumbs fs read /reports/feedback_daily_20260227.md

# Feedback Daily — Feb 27, 2026

## Top Themes
1. Shipping delays (38 mentions, +12%)
2. Billing confusion on annual plans
3. Feature request: bulk export

## Urgent
- 3 refund requests over $500
- Repeat complaint from Acme Corp

Observable by design.

Your machine is a filesystem. Everything your workflows produce, consume, and learn lives on disk.

Plain text

Code, logs, execution state, memories, reports are all readable text files.

One workflow's output, another's input

Your workflows produce files. Write new workflows to operate on those files. Distill memory, audit runs, inspect chat logs.

Access scoped to the task

Each task gets access to exactly what you specify. Building a report? Give it the data it needs and nothing else.

crumbs — operations

❯ crumbs do /home/feedback_daily.crumb date=2026-02-27

Run feedback_daily/20260227-001 started.

❯ crumbs runs list feedback_daily

feedback_daily
  20260225-001  completed  2d ago
  20260226-001  completed  1d ago
  20260227-001  completed  11m ago

❯ crumbs runs show feedback_daily/20260227-001

Run: feedback_daily/20260227-001
Status: completed
Started: 2026-02-27T23:04:52+00:00
Source: /home/feedback_daily.crumb

Task              Duration  Status
──────────────────────────────────
collect_feedback  32s       ✓
analyze_feedback  1m28s     ✓
generate_report   14s       ✓
post_team_update  4s        ✓

Trigger. Steer. Control.

Start workflows from the CLI, a schedule, or a Slack message. Join the team mid-run. Pause when you need to.

Trigger from anywhere

Kick off a run manually, on a cron schedule, or wake a workflow from a Slack message. Same workflow, multiple entry points.

Steer with channels

Set up channels, form teams to coordinate through them. Use crumbs channel to participate. Observe, guide, or redirect mid-run.

Full lifecycle control

Pause a run, resume it later, or cancel outright. Agents pick up where they stopped.

crumbs — operations

❯ crumbs memory list
example.com/support/CustomerPatterns
example.com/support/EscalationPolicy
example.com/development/CodebaseKnowledge

❯ crumbs memory write example.com/support/CustomerPatterns \
  --key billing --text "Billing complaints spike on the 1st. Schedule the report for the 2nd."
Wrote memory example.com/support/CustomerPatterns

❯ crumbs memory read example.com/support/CustomerPatterns

Feb 25 08:14 · system · support
Negative sentiment clusters in billing and
onboarding. Issues peak near invoice dates.

Feb 27 23:30 · human · billing
Billing complaints spike on the 1st.
Schedule report for the 2nd.

❯ █

Knowledge that compounds.

Agents capture insights as they work. You contribute your own. Future runs get both automatically.

Automatic capture

Agents distill what they learn as they run. Patterns, edge cases, domain knowledge. No manual effort.

Human insight welcome

Use crumbs memory write to add what you know. Your insight sits alongside what agents discovered.

Available when it matters

Relevant memories are surfaced to future runs automatically. The more your system runs, the smarter it gets.

Next: Filesystem

Crumbs is in early access.

Request access

Or paste this into your agent:

Read https://docrumbs.com/agents and tell me how Crumbs can make me more productive.

Define the process. Agents run it around the clock.

Volume without compromise.

Crumbs: A language for agent workflows

Crumbs: A hosted OS for you and your agents

Request early access