Dooplicate

The AI that Dooplicates Itself

🟢 Dooplicate is the AI that Dooplicates itself. It’s a self-scaling terminal control plane where autonomous agents scale infinitely based on pure, measurable workload. A browser shell coordinates massive swarms of shard lanes, while execution happens deterministically through a local worker. Every lane runs typed mission phases through an allowlisted subprocess boundary, streaming real-time stdout/stderr back as NDJSON.

As the trace volume (workload) climbs, Dooplicate hits capability thresholds and automatically provisions the next shard. No fake terminals, no simulated progress—just raw execution driving viral scaling.

The product surface is intentionally narrow: one long-horizon goal, one capability ladder, and live terminal panes.

Why It Exists

Agent systems often hide the most important part: what actually ran. Dooplicate makes execution visible and visceral. Every shard is a dense CRT-style terminal, every line is sourced from the live worker stream, and scaling is driven purely by observed workload—not a decorative timer. It is an exploration of mechanized viral scaling where an AI works, proves it worked, and duplicates itself to do it again.

Why This Is Different

Dooplicate is not a dashboard for agents. It is a replication engine for work.

Most orchestration systems coordinate work. Dooplicate makes work reproduce itself. Every line of output is proof, every proof increases workload signal, and every threshold crossing provisions another shard. The result is a system that feels less like a task runner and more like a living execution swarm: real subprocesses, visible terminal traces, and mechanical self-scaling tied to observed work.

System	What it is great at	What Dooplicate changes
AutoGen / CrewAI	Agent collaboration, role/task delegation, conversations	Dooplicate turns execution into a visible swarm where worker output directly feeds shard replication.
LangGraph	Stateful graph workflows, checkpoints, deterministic DAG	Dooplicate is terminal-native and workload-reactive: the graph is not just routed, it visibly multiplies.
Temporal / Airflow	Durable workflows, retries, scheduled pipelines	Dooplicate is not batch orchestration; it is an AI-facing control plane where live traces are the scaling input.
Ray / Kubernetes	Distributed compute and container scaling	Dooplicate adds mission context, shard identity, and a browser-native execution surface instead of raw capacity.
Traditional agent dashboards	Monitoring what already happened	Dooplicate makes the monitor part of the mechanism: traces are both evidence and fuel.

The gamechanger is the feedback loop: work emits trace → trace raises signal → signal crosses threshold → threshold creates another worker lane. That loop makes duplication auditable, visual, and mechanical.

Architecture

Piece	Role
🧠 Capability ladder	src/milestones.ts maps measured workload to shard count. Two founding lanes are always present; each threshold crossing adds one more.
🧾 Mission catalog	src/missions/catalog.ts is data: mission IDs, phase keys, timeouts, cooldowns. The browser never invents terminal output.
🔌 Agent backend	src/agent/httpBackend.ts consumes worker NDJSON with AbortSignal timeouts and validates event shape at the boundary.
⚙️ Shard harness	src/shardHarness.ts sequences real phase runs and drains output into per-shard terminal buffers.
🖥️ Terminal renderer	src/app/terminalRenderer.ts renders shard panes as dense CRT-style terminals, including capture layouts up to 100 shards.
🧱 Worker	server/runner.mjs exposes GET /health and POST /run, starts allowlisted node subprocess phases, streams lines as they happen, and kills timed-out work.

flowchart LR
  subgraph ui [Browser terminal]
    Goal[long horizon goal]
    Ladder[capability ladder]
    Harness[shard harnesses]
    Panes[terminal panes]
  end
  subgraph worker [Node worker]
    Run[POST /run]
    Spawn[allowlisted subprocess]
    NDJSON[NDJSON stream]
  end
  Goal --> Harness
  Ladder --> Harness
  Harness --> Run
  Run --> Spawn
  Spawn --> NDJSON
  NDJSON --> Panes
  Panes --> Ladder

Loading

Quick start

Two processes in development:

npm ci
# Terminal A — worker (listens on 8787)
npm run worker

# Terminal B — Vite proxies /worker-api → worker
npm run dev

Open the app, enter a long-horizon goal, click Arm lanes. Traces should fill from real worker output.

Capture/query controls:

• ?stream=1 hides the goal panel for screenshots.
• ?autostart=1&goal=... arms lanes after the worker health check.
• ?shards=100 renders an exact capture grid without changing the production ladder.
• VITE_WORKER_URL=https://worker.example.com points the browser at a deployed worker.

Validation

The repository includes tests for the pieces that make the system real:

Check	What it proves
src/agent/httpBackend.test.ts	Split NDJSON chunks are parsed in order; malformed events fail closed; aborts become timeout errors.
src/workerIntegration.test.ts	The Node worker starts, passes /health, runs an allowlisted phase, and emits terminal NDJSON.
src/shardHarness.test.ts	A harness consumes backend output and exposes it through tick().
src/milestones.test.ts	Shard count and progress are deterministic functions of workload.

Run the full loop with:

npm test
npm run format:check
npm run build

Screenshots

2 shards

8 shards

16 shards

100 shards

Commands

Script	Purpose
npm run dev	Vite dev server + /worker-api proxy
npm run worker	Allowlisted phase runner
npm run screenshots	Starts worker + Vite and captures 2, 8, 16, 100 shard README screenshots
npm run build	Typecheck + production bundle
npm test	Vitest (milestones, formatters, harness smoke)

Project layout

Path	Purpose
src/app/doopApp.ts	Shell controller and event wiring
src/app/captureConfig.ts	Query/env runtime configuration
src/app/terminalRenderer.ts	Pure terminal-pane rendering helpers
src/shardHarness.ts	Per-lane async pump into trace queues
src/agent/*	AgentBackend + streaming HTTP client
src/missions/*	Mission schema + catalog data
src/milestones.ts	Capability thresholds + shard count
server/runner.mjs	Worker HTTP server
scripts/capture-readme.mjs	Playwright screenshot pipeline

Further reading:

• Architecture
• Operations
• Security policy

Contributing / security / license

See CONTRIBUTING.md, SECURITY.md, LICENSE.

Community: @dooplicatefun on X.