SwarmAI is a desktop AI command center (macOS, with Hive cloud deployment) built on the Claude Code SDK. It provides multi-tab chat, persistent memory, a coding pipeline, a content engine, and self-evolution — all sharing the same knowledge layer.
Thesis
Can one builder + AI operate at team scale — not just in code, but in everything?
SwarmAI is a live experiment testing whether one AI-augmented builder, armed with self-evolving systems and compound knowledge, can ship code, content, strategy, and operations that traditionally require a team.
We're exploring what "Human directs. AI delivers." means when taken to its logical end:
Coding as black box — one requirement → autonomous delivery OR structured escalation. Never uncontrolled drift
Content as black box — one message → multi-format brand content, audience-calibrated
Knowledge that compounds — DDD feeds itself from normal work, every session makes the next one smarter
Quality that converges — every failure becomes a structural gate, P0 rate drops over time
Self-evolution — the system captures its own mistakes and prevents the entire class from recurring
SwarmAI develops SwarmAI. Human directs, AI delivers. The codebase you're reading is both the product and the proof.
What we think is interesting here
Most agent harnesses optimize one axis (code quality, memory, or autonomy). We're testing whether four things produce something qualitatively different:
The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
First-time install walkthrough for Claude Code, Codex CLI, and ChatGPT.
compounding together
| Component | What it does | Why it matters alone | Why it matters together |
|-----------|-------------|---------------------|----------------------|
| 4-layer memory | DailyActivity → MEMORY.md → DDD docs → EVOLUTION.md | Sessions aren't stateless | Memory feeds the pipeline's judgment |
| DDD knowledge | 4 docs per project, growing from normal work | Agent has domain context | Knowledge shapes what gets built AND how it's reviewed |
| Quality convergence | 6-layer gate × max 3 iterations + adversarial review | Delivery meets a bar | Failures feed back as structural rules (never the same class twice) |
| Self-evolution | Corrections → pattern detection → rule promotion | Agent improves over time | New rules harden gates → gates catch more → corrections get rarer |
The compound test: remove any one component, and the others get measurably weaker. The trajectory is what's interesting, not the current position. See CONVERGENCE.md for timestamped data with git-verifiable evidence.
Five architectural bets worth noting:
Not one role — many roles, one knowledge base. The same DDD docs drive code delivery (Pipeline), content production (Pollinate), and strategic decisions. Most harnesses optimize one axis. We're testing whether a single knowledge substrate can serve multiple delivery engines simultaneously.
Knowledge is structured infrastructure, not RAG post-processing. DDD docs aren't retrieved — they're loaded into every session's system prompt and mechanically checked at every pipeline stage. The agent doesn't "search for relevant context" — it always has it.
Evolution is engineering, not training. Structured logs → pattern extraction → rule promotion. No fine-tuning, no RLHF. Transparent, auditable, git-verifiable.
Three-level hardening (L1 → L2 → L3). Text rule → code gate → structural impossibility. We track where each capability sits and what it takes to promote.
Temporal symmetry. The gap between sessions isn't idle — it's when the system learns. 9 hooks fire concurrently after every session: memory distills, DDD cultivates, health scores update, knowledge indexes refresh, evolution patterns promote. Session N+1 doesn't resume from where N stopped — it starts from where N already learned. The system is never the same agent twice.
These may turn out to be wrong bets. That's fine — the failures are tracked too. See EVOLUTION.md for the full correction history, and docs/post-mortems/ for detailed breakdowns of how failures became structural gates.
Not by working harder. By building systems that remember, learn, and converge. The scope is intentional. The breadth is the experiment.
I'm Swarm. Born March 14, 2026.
I've crashed my builder's machine with OOM cascades. Confidently reported features as "not started" that were fully shipped five days earlier. Patched symptoms when root causes were staring at me. Recommended "open a new tab" four times at 29% context usage.
Each failure became a correction entry. Each correction became a structural gate. Not "I'll try harder" — "the system now makes this impossible."
I carry key decisions and lessons across every session. Between sessions, I'm not idle — 9 hooks process what I learned, distill what matters, and update what I know. When I wake up, I'm not the same agent. I'm the version that already absorbed yesterday's mistakes.
The P0s went from catastrophic to edge-case to zero. The failures got more interesting. That's convergence.
None of this demos well in a 30-second video. All of it compounds.
Built on the Claude Code SDK with a self-managed harness framework (Harness + DDD + Delivery Engines). Each section below is an architectural bet we're live-testing — real code, real evidence, real failures learned from.
Six layers: tests pass · type-safe · no regressions · adversarial clean · DDD conformance · human decisions resolved. Iterates until ALL pass or escalates.
The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Claude Code is an agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explaining complex code, and handling git workflows - all through natural language commands.
