v0.8.0 · Workspaces + Repository

Ship a week of code in a weekend.

Parallel AI coding agents in isolated git worktrees, supervised from one screen. Bring the Claude or Codex subscription you already pay for.

Install in 30 seconds See the docs

20+ parallel workspaces
Your subscription, no markup
Local-first, replayable
Any sandbox · Any IDE

Parallel agents

Spawn 20 agents. Stay sane.

Every workspace is its own git worktree, its own sandbox, its own port range. Agents can't trip over each other.

Declare your repo in fabled.json

Sandbox provider, lifecycle scripts, egress allowlist, agent modes — declared once at the repo root.

Spawn workspaces with Cmd+Shift+N

Each gets its own git worktree, port range, and Docker, Podman, or raw shell. They never share state.

Review diffs side-by-side

Line-by-line diffs with inline comments, synced to your GitHub PR. Merge with Cmd+Shift+P.

Live · 20 workspaces

tasks/sec0merges/hr0

w-01mergedclaude-code

w-02runningcodex

w-03evalclaude-code

w-04runningclaude-code

w-05planningcodex

w-06mergedclaude-code

w-07runningclaude-code

w-08evalcodex

w-09runningclaude-code

w-10mergedcodex

w-11planningclaude-code

w-12runningcodex

w-13evalclaude-code

w-14runningclaude-code

w-15mergedclaude-code

w-16runningcodex

w-17planningclaude-code

w-18evalcodex

w-19runningclaude-code

w-20mergedclaude-code

w-01 · merged · feat(api): batch ingestw-08 · eval · pending charter checkw-04 · running · drafting fix(auth)w-10 · merged · refactor(workspaces)w-15 · merged · test(audit) +14 casesw-03 · eval · risk flagged → suspendw-19 · running · file: routes/[org].tsxw-20 · merged · perf(sandbox) -38ms

Isolation

Pick your isolation. Same workspace, any sandbox.

One trait. Local containers, microVMs, or hosted sandboxes — swap providers in fabled.json without touching code.

On your machine

Today

docker

Rootless containers with CPU, memory, and PID caps.

podman

Daemonless, rootless containers — same caps, no Docker socket.

no-sandbox

Raw shell on your machine. For trusted local runs only.

In the cloud

Coming through 2026

firecracker

MicroVM isolation, sub-100 ms cold-start, kernel-level boundary.

vercel sandboxes

Ephemeral cloud sandbox with allowlisted egress routing.

e2b

Hosted code-execution sandbox with snapshot-fast warm pool.

modal

Serverless cloud-burst for hardware-heavy or fan-out runs.

fabled.jsonjson

// pick any provider — the rest of fabled.json stays put
"sandbox": {
  "provider": "docker", // → "podman" | "firecracker" | "vercel" | …
  "resourceCaps": { "cpus": 2, "memoryMib": 4096 },
  "egress": { "allowlist": ["github.com", "api.anthropic.com"] },
  "timeoutSec": { "perStep": 600, "abort": "sigterm-200ms-sigkill" }
}

Same per-step timeout taxonomy, same SIGTERM → 200 ms → SIGKILL abort, same line-streamed stdout — across every provider.

Capabilities

Built for the way you actually work.

No half-built primitives. Every workspace gets isolation, observability, and a real review surface — from day one.

Per-workspace git worktrees.

Isolation by construction. Each workspace lives at ~/.fabledos/workspaces/<id>/ with its own branch, port range, and lifecycle. No cross-branch contamination, no stomping merges.

Worktree locks survive crashes
Lineage trailer on every merge
Archive + restore in one keystroke

Sandbox-aware policy.

Resource caps, egress allowlists, per-step timeouts, abort on SIGTERM — every primitive enforced before the agent touches code, on every provider.

Per-step timeout taxonomy
Per-workspace egress allowlist
SIGTERM → 200 ms → SIGKILL

Diff Viewer with inline comments.

Line-by-line unified diff with threaded comments. Drops directly into the GitHub PR — agents read the same comments on their next turn.

GitHub-synced threads
File-tree filter
Resolve from CLI

Checks tab.

Git status, CI runs, PR metadata, deployments, comments, todos — every signal a senior reviewer wants, one pane of glass.

gh-CLI integration
CI re-run inline
Stalled-deploy nudge

Plan / Fast / Reasoning modes.

Match cognition to the task. Swap Claude Code ↔ Codex per workspace via fabled.json — no engine rewrites, no keyboard detours.

Cmd+Shift+N · workspace
Cmd+Shift+P · open PR
Engine swap via config

Hash-chained audit trail.

Every decision, every tool call — appended to a hash-chained log on disk. SQL-query the mirror, replay any run, export redacted slices for audit.

fabled audit verify
fabled audit query
Redacted PII export

Inside a workspace

See the whole loop.

Declare your repo, spawn a workspace, audit any decision — no magic, no hidden state.

One file at your repo root declares everything FabledOS needs to spin up a workspace — sandbox, scripts, allowlist, agent modes.

fabled.jsonjson

{
  "$schema": "https://fabledos.com/schema/fabled.json/v1",
  "scripts": {
    "setup": "bun install && cp .env.example .env.local",
    "run": "bun run dev",
    "archive": "rm -rf .fabled/cache"
  },
  "agents": {
    "allow": ["claude-code", "codex"],
    "default": "claude-code",
    "modes": ["plan", "fast", "reasoning"]
  },
  "sandbox": {
    "provider": "docker",
    "resourceCaps": { "cpus": 2, "memoryMib": 4096 },
    "egress": { "allowlist": ["github.com", "api.anthropic.com"] }
  }
}

Cognition

Bring your model. Keep your IDE.

FabledOS runs on the subscription you already pay for and exposes itself as an MCP server — any editor that speaks MCP picks it up without a fork.

Your subscription, no markup.

The CLI you already log into runs the work. Every model call lands on the provider from your machine — your rate limit, your bill, zero proxy in the middle.

Claude Max · Codex
Engine swap via fabled.json
Zero per-token billing on our side

API keys when you need them.

Bring an Anthropic, OpenAI, AWS Bedrock, Google Vertex, Azure, Mistral, Cohere, Groq, or local Ollama key for anything the subscription path doesn't cover. Keys land in your OS keychain — never on our servers.

OS keychain primary
0600 file fallback
Keys never traverse our cloud

MCP-native, IDE-agnostic.

Run fabled mcp serve and FabledOS exposes workspace, audit, and policy as first-class MCP tools. Any editor that already speaks MCP picks them up — no fork, no plugin store, no per-editor wrapper.

One serve command
Six MCP tools at v1
Bring your own editor

Eight stable ports — cognition · audit · policy · memory · attestation · payment · queue · auth. Every adapter swappable in isolation.

Install

Install in 30 seconds.

Pick the surface that fits your day. The same workspaces follow you across all three.

Terminal-native power. Spawn workspaces, run agents, review diffs — without leaving your shell. Pick your package manager:

macOS · Homebrew

Homebrewbash

$ brew install himudianda/fabledos/fabled

Linux · Linuxbrew

Linuxbrewbash

$ brew install himudianda/fabledos/fabled

Windows · Scoop

Scoopbash

$ scoop bucket add fabledos https://github.com/himudianda/scoop-fabledos && scoop install fabled

Anywhere · npm

npmbash

$ npm install -g @fabledos/cli

Then sign in and create your first workspace:

terminalzsh

$ fabled auth login
$ fabled workspace create --repo ~/your-project

Roadmap

Phase 1 today. The substrate, long-term.

What ships now, what's coming, where it ends up.

Shipped

Parallel agents, supervised.

Everything above is live in v1.0. Local-first, cross-platform, audit-from-day-one.

Sandbox-agnostic runtime (Docker · Podman · raw shell today, microVMs + hosted next)
Three surfaces — CLI, native desktop, web account
Hash-chained, replayable audit trail

Coming next

From parallel to autonomous.

Declare your team's working agreement once. Let evaluated agents merge while you sleep.

Charter-based governance primitives
Eval-gated merge with signed attestations
Team control plane on the web
MCP-native federation across editors and orgs

The destination

A learning runtime.

Evidence flows in; the runtime proposes refinements; you approve; behavior changes — without writing code.

Closed-loop learning from execution evidence
Federated policy across teams and orgs
On-chain attestations for high-risk decisions

FAQ

The questions a senior dev would ask.

Lock-in, sandbox safety, bring-your-own model, what you keep if you cancel. Honest answers.

Ready to ship

Stop watching agents one at a time.

Install in 30 seconds. Your subscription already covers the inference. You bring the backlog.

Install the CLI Create an account Read the docs

Free forever for local fleets. No credit card. No token markup. Ever.

Ship a week of codea week of code in a weekend.

Spawn 20 agents. Stay sane.

Declare your repo in fabled.json

Spawn workspaces with Cmd+Shift+N

Review diffs side-by-side

Pick your isolation. Same workspace, any sandbox.

On your machine

In the cloud

Built for the way you actually work.

Per-workspace git worktrees.

Sandbox-aware policy.

Diff Viewer with inline comments.

Checks tab.

Plan / Fast / Reasoning modes.

Hash-chained audit trail.

See the whole loop.

Bring your model. Keep your IDE.

Your subscription, no markup.

API keys when you need them.

MCP-native, IDE-agnostic.

Install in 30 seconds.

Phase 1 today. The substrate, long-term.

Parallel agents, supervised.

From parallel to autonomous.

A learning runtime.

The questions a senior dev would ask.

Do I have to use a specific model?

Are you proxying my tokens or charging a markup?

How safe is running 20 agents in parallel?

Am I locked in?

Local vs cloud — what runs where?

Is macOS / Linux / Windows real parity?

What is the daemon doing in the background?

Does this work with my editor?

Can I run agents in the cloud, not just locally?

Can my team share workspaces?

Where do my API keys actually live?

How do I trust the policy engine?

How do I trust the audit trail?

What happens if I cancel?

Stop watching agents one at a time.

Ship a week of code in a weekend.