Real usage · Start here · Session Manager · sessions rail.
An operating runtime for multi-agent CLI workflows. Below: the operator cockpit (vc-frame) and the control-plane desk (vc-server) — real frames, not mockups.
curl -fsSL https://vibecrafted.io/install.sh | bash One installer, six components, one directory of truth. Here is exactly what lands on your machine, where it lives, and which part of the mess each piece exists to kill.
The runtime and the launchers. vibecrafted <skill> <agent> dispatches real work to claude, codex, gemini or junie, records every run in the control plane, and settles it as f / x / n with receipts — report, transcript, seal.
Kills the untracked agent session: work that happened somewhere, left a diff, and nobody can say who ran what or whether it finished.
Structural perception. Repo map, dependency slices, consumers, blast radius, dead code — the map an agent reads before it touches your code.
Kills the blind edit: the refactor that broke three consumers nobody knew existed.
Parses agent transcripts — Claude, Codex, Gemini — into a searchable intent store. What was decided, by whom, and why: retrievable, not folklore.
Kills the amnesiac session: the agent that re-decides on Tuesday what the team already settled on Monday.
The operator terminal (a hard fork of Zellij): session rail, live-run chips, command composer, paste stack. Where you watch the fleet work — and interrupt it.
Kills the fifteen-tab terminal sprawl where the important session is always the one you closed.
A read-only browser projection of the same control plane the CLI writes: live runs, lifecycle decisions, transcripts, scaffold review. Leptos SSR + axum. It observes; it cannot mutate your repo.
Kills the dashboard that invents its own numbers — alive / final / failed / attention come from retained snapshots, not vibes.
Agency on your Slack, self-hosted. Agents post, reply, react, DM and hand off to each other in bounded threads — under operator-controlled scopes, with tokens that never leave your side.
Kills the invisible fleet: dispatch and read reports in the channel your team already lives in, instead of ssh-ing in to check.
Not hating on vibe coding — AI generation gets you to launch, and that matters more than most engineers will admit. But the founder who built the product in a weekend eventually hits the wall: the enterprise deal stalls, the security review fails, the second developer quits in a week. This is the Vibe Hangover. Here is what we keep finding under the hood.
Every user is either admin or user. No roles, no row-level permissions, no audit log — and session tokens in localStorage like it's 2019. We watched a $40k annual deal die in the first ten minutes of the prospect's technical review. The product was solid. The architecture screamed weekend project.
Everything in one 35-column model. Fine — until 10k rows make every page load a full-table scan. One founder paid Vercel $300 a month for functions timing out on unindexed queries and retrying forever. Real relations and indexes brought the bill to $40. Same app, same traffic.
When one thing breaks, everything goes down — silently. A webhook handler crashed on an annual-billing edge case and one founder lost about 8% of subscription payments for two months. Customers emailed about it. The system never did.
No staging, no tests, live keys in the repo. One Friday deploy took an app down for 11 hours because a migration deleted a column that was still needed. Users saw a blank screen all weekend; fifteen paying accounts churned.
The vocabulary can stay vivid, as long as the system remains inspectable: context before edits, evidence after runs, and a release surface that says what is still uncertain.
Models drift when they write into a repo blind. Structural maps give the session landmarks before the agent touches a file.
Code generation is noisy. The Marbles loop gives that noise a place to show up: small loops, counterexamples, and visible unresolved work.
Structured Human-AI collaborative engineering. The craft is in the handoff: humans keep scope, taste, and irreversible decisions; agents do fieldwork with evidence attached.
Without a board
The next session may inherit a diff, but not the reason behind it. The repo has changes; the work has no memory.
A green build starts to feel like proof. It is useful signal, but not enough to know whether the product is safe.
Artifacts collect in comments, branches, notes, and screenshots. A future agent can see pieces, but not the shape.
With a board
Scope, owner, evidence, and next action sit on the same surface before the agent starts cutting.
Reports and artifacts stay attached to the repo, so the next session can continue from evidence instead of mood.
The board does not declare victory. It shows what landed, what moved, and what still asks for a decision.
05 PHASES
06 OPERATORS
01 SHARED BOARD
00 LOST CONTEXT
Eleven stages alternate Read and Write. Every write — implement, marbles, polarize — is immediately falsified by a read — review, audit, DoU. Marbles loops fixes until the gates stop lying; Polarize picks one canonical behavior and makes code, tests, and docs agree on it. Each stage runs its leg and hands the baton to the next, so nothing ships unchecked.
read · map before the cut
write · agents deliver
read · falsify the write
write · marbles ⬆ polarize ⬇
write · ship for strangers
%%{init: {
"theme": "base",
"themeVariables": {
"background": "#07111f",
"primaryColor": "#0c1626",
"primaryTextColor": "#f3efe7",
"primaryBorderColor": "#2d3b56",
"lineColor": "#d8894b",
"secondaryColor": "#101b2d",
"tertiaryColor": "#0d1728",
"fontFamily": "Inter, ui-sans-serif, system-ui, sans-serif",
"fontSize": "16px"
},
"flowchart": {
"curve": "basis",
"htmlLabels": true,
"nodeSpacing": 32,
"rankSpacing": 46,
"padding": 14
}
} }%%
flowchart LR
S["Scaffold · R"] --> I["Implement · W"]
I --> RV["Review · R"]
RV --> WF["Workflow · W"]
WF --> FU["Follow-up · R"]
FU --> MA{{"Marbles · W ⬆"}}
MA --> AU["Audit · R"]
AU --> PO{{"Polarize · W ⬇"}}
PO --> DU["DoU · R"]
DU --> HY["Hydrate · W"]
HY --> RE["Release · W"]
classDef read fill:#0d1728,stroke:#3b6ea5,color:#dbe7f3,stroke-width:1.3px;
classDef write fill:#1a1410,stroke:#d8894b,color:#ffd9bd,stroke-width:1.6px;
classDef core fill:#1a1110,stroke:#e2935a,color:#ffd9bd,stroke-width:2.4px;
class S,RV,FU,AU,DU read;
class I,WF,HY,RE write;
class MA,PO core;Each workflow has one job. Read the repo, make the cut, test the real path, or audit what is still not ready. Names come later; the evidence comes first.
$ curl -fsSL https://vibecrafted.io/install.sh | bash One local bootstrap from the published 3.6.0 artifact — not a private checkout. $ vibecrafted doctor Health check: foundations prebuilt-first, control plane staged, VERSION stamped. $ vibecrafted init claude First-context pass: Loctree map + AICX intent before any agent cuts code. The operator cockpit ships with the session-manager rail welded into dashboard, marbles, operator, research, and workflow layouts. Tab inventory stays honest; fleet settlement lives on the Mission Control board — not the rail.
A session can end without disappearing. The operator is an agent: it runs the relay, and each leg hands the baton to the next runner — the next agent inherits reports, decisions, and open questions, not a cold prompt. You stay the founder — scope, taste, the hard transitions, the feel of the project — you never run the legs yourself.
Start with the boring signal: does the launcher know where it is, what is installed, and what needs attention?
$ vibecrafted doctor Init may surface repo shape, recent context, and the first risks before any edit starts.
$ vibecrafted init claude Workflow helps when the task needs a little ceremony: examine the surface, research the gap, then implement the cut.
$ vibecrafted workflow claude --prompt "Plan and implement <task>" Marbles runs small counterexample loops. It may find an edge case, a false assumption, or simply a place that needs a human decision.
$ vibecrafted marbles codex --count 3 --depth 3 DoU is the moment to stop pretending. It asks what is missing across install, docs, runtime, trust, and release.
$ vibecrafted dou claude --prompt "Audit launch readiness" Release gathers the outward work: artifacts, deployment notes, docs, and the next human-readable step.
$ vibecrafted release codex --prompt "Prepare release steps" The convergence framework is the synthesis of research on agent handoffs, release gates, and runtime contracts. Sources below — consult before adopting.
A few field notes from the wild — from agent-built products and our own release lanes. Anonymized, because the pattern says more than the name.
The upstream framework was already fixed, but the public landing repo still served older installer truth. Everyone was right inside their own checkout; the user saw drift.
FIELD NOTE · representative repo release laneA helper script kept yesterday's path assumptions after the main runtime flow was repaired. The product worked, until an operator followed the stale trail.
FIELD NOTE · helper surface auditA checkout path looked healthy until activation moved into claim and webhook truth. The sale happened; the entitlement story still needed a witness.
OBSERVED · real founder (redacted)No staging, no smoke tests, no rollback. The migration deadlocks on a lock table. Support tickets spike while the founder tries to remember which tab ran last.
OBSERVED · field reportsNot the first-time vibe coder — the post-vibe cleanup buyer. Technical founders and small eng teams.
Open core for the engineer who inherited AI-written change. Paid pilots at full seat price. Forge when regulated.
Green main is engineering evidence, not a product verdict. Numbers map to PRs and live corpus rates.
CLI + MCP + self-host. Your keys. Your mesh.
Hosted control + bus for teams cleaning up AI-written change.
Regulated / EU / air-gap. White-label audit plumbing.
One sharp wedge as MCP, OSS hook, outreach to 30 technical founders — measure paid pilots at ≥$49/seat without discount games.
Start paid pilotMap · impact · evidence report on a real PR.
Technical founders / small eng teams only.
Named buying moment + written success criteria.
Repeatable channel — or hedge / private tooling.