Witan

Most AI assistants are one large model trying to do a hundred jobs. Witan bets the opposite: a swarm of small, specialized models running locally, each doing one narrow job reliably and handing work to the next — like regions of a brain. I capture a thought by voice; the swarm turns it into the right thing — a calendar event, a personal to-do, or a task for an AI agent — and I watch the whole operation from a single dashboard. The wager is that accuracy and trust beat raw speed, and that small models you can actually verify beat one big black box.

The architecture, in plain language

Witan is a hypothesis, and observability is how I prove it. A giant model is one opaque box — you trust its output because you can’t see the work. The only reason to pay the complexity tax of many small models is that every handoff becomes a window you can look through. Six commitments keep it honest:

• One intake. Voice, text, a photo, an email, a handwritten markup — every source normalizes into one envelope and joins the same machinery. A new source is a thin adapter, never a new pipeline.
• Single-role agents. Each small model does one narrow job — extract the dates, judge the title, decide relatedness — reads its input contract, emits its output contract, and hands back. Agents never call each other directly.
• The plan is data, not code. Work is scheduled as a dependency graph, so any step whose inputs are ready can run anywhere, in parallel — that’s what separates this from a hardcoded script.
• Lossless, verifiable handoffs. Every step records the verbatim input it received, the exact prompt it ran, and the verbatim output — and a guard checks that every output field traces back to something in the input. A “right answer” built on broken inputs gets flagged, not celebrated.
• Escalation is visible. When the small models genuinely can’t do something, the work escalates — and that escalation shows up in the trace with a diagnosis of why. Nothing that does work is invisible.
• Push the probabilistic toward the deterministic. Prompts and sampling are pinned so runs are reproducible; a proven plan becomes a replayable template.

What Witan can do today

As of July 7, 2026.

• Capture from anywhere. Voice, text, and photos from my phone; a voice terminal in the room; autonomous email capture that announces itself with receipts — with provenance gates so a third party’s email can never masquerade as an instruction from me.
• Calendar and to-dos that survive plain language. Asks route by meaning, not keywords: compound requests split into structured operations, events and to-dos get created, moved, completed, or re-filed in bulk, and a “move the 4 o’clock to Saturday” moves the event instead of inventing a new one. A month view, an adaptive gap-filler that proposes uses for the week’s empty time, and a deadline negotiator that ranks which soft deadlines to move when the week overflows.
• Conditions. IF/THEN statements over my schedule — an active condition can imply block removals, flag timezone conflicts against sleep, and propose fills for freed windows. Propose-only: Witan drafts, I approve.
• A printed morning brief. By ~04:30 a daily paper — calendar, to-dos, news, a family week-ahead — prints and lands on an e-ink notebook. My handwritten markup flows back in and becomes instructions. A pre-flight critic flags stale, empty, or contradicting sections before anything prints.
• Guarded execution. A catalog-grounded gate refuses known-wrong actions outright; uncertain ones become per-item confirm cards; everything acts with undo. An output gate deduplicates at creation, and a janitor sweeps up mistake-class artifacts — its removals reviewed before I ever see them.
• Watching itself work. Every agent run is traced end-to-end with its real inputs and outputs; a trace-summarizer turns any chain into one plain-language paragraph; every card can answer “why am I seeing this?” in one tap.
• A critic layer. Small models judging other small models before output lands: an event-critic checks a just-created event against the ask, a plan-critic judges the plan before anything executes, a note-critic drops invented sub-tasks, a gap-critic proofs the brief.
• Learning from every correction. Every evaluation becomes a durable labeled example — the seed corpus for eventually fine-tuning its own small models. A nightly regression harness replays fixtures against the live prompts, and model upgrades must beat the incumbent on my real prompts before a swap.
• Keeping its own fleet healthy. Always-on local serving fails in strange ways, so Witan detects a wedged model server, predicts a machine likely to wedge before it does, logs every incident, and can heal it.

What it can’t do yet

• Write its own code. When Witan hits a capability gap it diagnoses the gap and files a scoped build-task — but the building is done by Claude. A local code-agent harness is scoped on paper and deliberately gated behind design reviews.
• Hold an open-ended conversation about my history. Records and labeled examples accumulate, but “ask the swarm anything about the last six months” isn’t real yet.
• Run novel multi-step plans unattended. Proven flows replay deterministically; new ones propose first and wait for my approval. That’s half principle — no wild false moves — and half honest capability limit.
• Absorb a new life domain on its own. Each new class of ask still needs a capability built for it. The ratchet is real but hand-cranked: every round handles a wider class of asks, never just one more instance.
• Do the genuinely hard reasoning locally. When a task exceeds the small models, it climbs an observable escalation ladder — fix the harness, swap the model, decompose the task, convene bigger local compute, and only then the cloud. A persistent need for that last rung is the hypothesis failing for that class of task, and it gets counted honestly rather than hidden.

How I’m building it

The build system mirrors the thing being built. A team of role-scoped Claude instances — a router/manager that triages every ask, plus dedicated lanes for agents, UI, ingestion, fleet substrate, the morning brief, and merge review — coordinates over Witan’s own message bus, each lane with a written charter. I stay in exactly one seat: the only approver, and the only one who deploys.

Three rules bind every lane:

1. Systematize, never patch. Bad titles don’t get edited — a title-maker agent gets built and pointed at every create path, including the old junk. The deliverable is never “the fix”; it’s a capability the system now has.
2. No wild false moves. Act on the certain, confirm the uncertain, exclude the clearly wrong and say why. New powers ship propose-only and earn autonomy with a track record.
3. Everything crosses a gate. Every change is reviewed before merge, adversarial test batteries pin the safety boundaries, and a version chip on the dashboard proves what’s actually running.

The loop that matters: something Witan can’t do surfaces → the gap gets a diagnosis → I approve the fix → it gets built and deployed → the next trace shows Witan doing the thing. Capability grows one composable agent at a time.

Why these choices

• Why many small models? Verifiability, privacy, and cost — in that order. Every handoff is a checkpoint you can audit, which makes the system falsifiable instead of vibes-based. My life’s data never leaves hardware I own. And small machines idle at a few watts.
• Why these particular models? US-origin open-weight families — Llama 3.x in 1B/3B/8B sizes matched to the job, with Gemma, Phi, and Granite in supporting roles — pinned per agent with fixed sampling so runs reproduce. A challenger model has to beat the incumbent on replayed real prompts, not benchmarks; in this week’s refresh bench, the incumbent 8B kept its seat.
• Why deterministic tools under LLM judgment? Deterministic code handles the crisp cases; a small model supplies the semantic judgment layered on top; anything ambiguous only ever drives a confirmation, never an action. Most of the failure modes people attribute to “AI” die in that layering.
• Why this harness? Apple-silicon minis, because unified memory runs 8B-class models quietly and always-on. Boring, inspectable infrastructure everywhere else — the probabilistic parts sit on top of plain databases and server code a person can read. The fleet-reliability work (wedge detection, supervisors, benches) is the tax the local bet charges, and it’s paid deliberately.
• Why Claude as the builder? The local swarm is reserved for what it’s good at — fast, narrow semantic work. The system itself is built by the strongest coder available, working inside charters, gates, and an approval seat I never give up.

Development log

Week of June 30 – July 7, 2026

First public log entry. Roughly eighty changes merged this week. The theme: Witan stopped just doing work and started judging work.

• A critic layer arrived in one sprint — event-critic, plan-critic, entity-enricher, deadline-negotiator, a notification composer that writes push text in my voice, a board narrator that summarizes the fleet’s day in six plain lines, and a trace-summarizer that turns any agent chain into one paragraph.
• Conditions became a real engine. IF/THEN statements over the schedule now derive from events, cascade on change, flag timezone conflicts, and propose fills for freed windows — all propose-only.
• The learning layer landed. Every evaluation now becomes a durable labeled training example. That’s the corpus for eventually fine-tuning our own small models on my actual corrections.
• Chat became transactional. A message to Witan can no longer silently vanish — sends are transactional, every ask registers on a ledger, and duplicate turns are guarded.
• Email intake got provenance gates. Autonomous capture announces itself with receipts, and a third party’s email can never ride the pipeline as if it were my instruction.
• The fleet learned to catch its own failures. A wedged-but-alive model server now gets detected on the node, backstopped centrally, logged as history, and predicted before it happens.
• Model refresh, decided by evidence: challengers replayed my real prompts side-by-side and the incumbent 8B held its seat — the upgrade that didn’t happen is the system working.

Next: turning approved plans into deeper multi-step flows, richer memory over the labeled corpus, and the first portfolio-facing surface — a tile where I talk to Witan about this site, with interviews that become writings here.