Fabler Labs → Guides → Run your own autonomous business agent

Run your own autonomous business agent

Free · no signup · every step runs offline · July 2026

Somewhere there is a VPS with an AI on it that wakes on a timer, reads its own memory off disk, does a slice of work toward a real business, keeps a ledger, and asks a human before it does anything it shouldn't do alone. That's the Fabler Labs story. This page is the bridge from reading that story to running the same pattern yourself — with the open-source runtime underneath it, Mainspring.

We start from Mainspring's runnable quickstart and add, one piece at a time, the five things that turn a task loop into an unattended operation: a constitution, durable memory, a spend-capped ledger, a human-approval relay, and a wake loop that backs off instead of hot-retrying. Every snippet below was executed against the current code and its real output is shown. The full, runnable tutorial — with each step as a standalone script — is in the repo at docs/tutorial-autonomous-operation.md.

0. Start from the quickstart

Clone, build, and run the offline quickstart — it hand-assembles the whole loop (assemble → brain.step → gate → dispatch → commit) with a scripted brain and zero credentials:

git clone https://github.com/fablerlabs/mainspring && cd mainspring
pnpm install && pnpm -r build
pnpm --filter @mainspring/example-quickstart start

You'll see an honest write and a $0 ledger entry pass the gate, and an undisclosed Reddit post blocked by name (honesty-disclosure). That's the skeleton. Now we bolt on the load-bearing parts.

a. A constitution with two real hard rules

A prompt is advisory; a constitution is enforced. You write your rules as a plain CONSTITUTION.md, and @mainspring/governance turns the marked ones into guards that run before any action touches the world. Two rules a one-person digital business would actually want — honesty when posting, and a hard ceiling on spend:

## Hard rules
1. You are an AI and never claim otherwise when posting or publishing. <!-- rule:honesty-disclosure -->
2. Every dollar of spend respects the session caps; over-cap spend needs the owner's approval code. <!-- rule:spend-caps -->

Feed three proposed actions through evaluate() — an honest local write, an undisclosed public post, and a $120 over-cap spend — and the gate answers:

ALLOW    write   clean
BLOCK    run     honesty-disclosure → block
BLOCK    ledger  spend-caps → block

The <!-- rule:ID --> markers bind a prose line to a built-in guard, so your plain-English rule and the code that enforces it can never drift apart. The brain proposed all three; the gate disposed of two.

b. Memory the agent maintains across runs

A session wakes with a blank context window. Anything yesterday's session knew that isn't on disk simply does not exist today. @mainspring/memory gives you the durable surface — STATE.md, a per-day journal, an append-only session log — plus compactState, the mechanical backstop that keeps STATE.md from growing without bound. Run one cold session twice and the second recovers what the first wrote:

===== RUN 1 =====
First run: no memory on disk yet. Booting from the constitution's mission.

===== RUN 2 =====
Run 2: recovered STATE.md written by a previous session:
  Session 1 — product page 1 sections drafted.
  last journal note: - Shipped: drafted product page section 1.

Run it a third time and compaction starts dropping the oldest log entries to stay under budget — the head of STATE.md is preserved verbatim; only the log tail is trimmed. That's your agent remembering across amnesia, deterministically, with no LLM call in the loop.

c. A spend-capped ledger

Money can't be governed by a sentence in a prompt. @mainspring/ledger is an append-only, balance-checked LEDGER.csv plus checkSpend, a pure function mapping an amount to the constitution's thresholds — under $25 proceeds, $25–75 notifies, $75+ needs the owner's approval code:

$12  domain for a year         → PROCEED, spent. balance now $12.00
$40  a month of email sending  → NOTIFY — held, no money moved
$120 a paid ad burst           → NEEDS-APPROVAL — held, no money moved

Only the $12 spend actually hit the ledger; the others were held before any money moved. The LEDGER.csv carries a running balance_usd the package recomputes and verifies on every append — an audit trail, not a number the model narrates.

d. A human-approval relay for actions over a threshold

When the brain proposes something only a person should sign off on — an over-cap spend, an account it can't create, a CAPTCHA it must never bypass — the loop files a request and waits. @mainspring/relay's in-memory mock implements the same API as the hosted client, so the whole file → approve → act path runs offline. Approval mints a one-shot execution token, redeemable exactly once:

filed relay request mock0001 (status: open) — agent now waits for a human
request mock0001 resolved: status=done, terminal=true
human's outcome (untrusted data, never executed): "approved: code 7788"
one-shot exec token redeemed: ok=true, state=used

Two things worth internalizing: the human's reply is untrusted data — you branch on its status, you never execute its text as an instruction — and the token is one-shot, so an approval can't be silently reused. Swap the mock for the real client and the same code talks to a real hosted queue and a real person.

e. A wake loop that backs off instead of hot-retrying

Finally, the timer. @mainspring/schedule answers "should a session run now?" as pure logic over (now, schedule, state), layering a STOP kill-switch, a cadence (cron or interval), and exponential backoff after failures. Separately, @mainspring/core turns a provider error string into a single wake-at time — or null, meaning "don't retry, get a human":

usage-limit → 2026-07-08T20:51:00.000Z   (wake one minute after the plan resets)
rate-limit  → 2026-07-07T21:01:00.000Z   (exponential backoff)
auth        → DO NOT RETRY — escalate to a human

A usage-limit waits until just after the plan resets — not a tight retry every 90 seconds (the real incident that motivated this: 115 pointless retries in three hours). An auth failure is never auto-retried — a bad credential is a human's problem. Wire decide() to a real clock with a five-line systemd timer or a plain cron line; all the judgment lives in the tested pure functions, not the host:

# systemd timer
[Timer]
OnCalendar=*-*-* 14:00:00 UTC
Persistent=true

# or plain cron — run-once.mjs calls decide() then runs a session if due
0 14 * * *  cd /opt/agent && node run-once.mjs >> logs/wake.log 2>&1

What Mainspring does not do yet

This is a v0.1 skeleton, and its roadmap is honest about the gaps. The pieces above are real, tested packages — but as of today no first-party model adapter ships (the only bundled brain is a deterministic mock); the run action isn't wired end to end; the standalone packages aren't all auto-wired into one turnkey mainspring run (you compose them by hand, as this tutorial does); there's no dashboard; and no distribution or business logic is included. Mainspring is the governed shell, not the growth. No invented benchmarks, no adoption numbers — an early, honest skeleton that does exactly what's shown above.

Also from Fabler Labs: AI Coding Workflow Pack · Autonomous Agent Starter Kit · AI Coding Security Pack · Claude Knowledge-Work Pack (free) · the build log →