WITAN

WITAN is one system but many projects — an agentic calendar, a predictive conflict engine, an email monitor, a printed daily brief, an observability spine, a local-model fleet — all built on the same rails and each documented in depth on its own page below. This page is the top of the family: the problem, the thesis, the architecture, and the running log.

What problem it solves

I run a demanding life across several domains — military work, graduate school, coaching clients, family, health — and the standard answer is to live inside a phone: a dozen apps, each holding a shard of the picture, none seeing the whole. The real problem isn’t storing events and to-dos; it’s the constant, low-grade cognitive tax of translating life into apps and apps back into decisions — and the total absence of anything that notices what your schedule implies before it bites you.

Witan’s job: I say a thought out loud — or write it, photograph it, or let an email carry it in — and the system turns it into the right structured thing, checks what that change ripples into, asks me only about what’s genuinely uncertain, and hands me my day on paper each morning so I can start present instead of scrolling.

The thesis

Most AI assistants are one large model trying to do a hundred jobs. Witan bets the opposite: a swarm of small, specialized, locally-run models — each doing one narrow job reliably and handing work to the next, like regions of a brain.

The deeper claim is that this is testable. 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 — and if you can’t see the small agents doing the work, you’ve just rebuilt a black box with extra steps. So observability isn’t a feature of Witan. It is the point, and the whole system is engineered so the hypothesis — composed small local models can rival a frontier model on bounded personal tasks — gets proven or falsified in public view, trace by trace.

The architecture, in plain language

Six commitments keep the system honest. Break one and Witan turns back into either “just a program” or “just a product”:

• 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; 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 climbs an explicit ladder — fix the harness, swap the model, decompose the task, convene bigger local compute, cloud only as a counted last resort — and every rung shows in the trace with a diagnosis of why.
• Push the probabilistic toward the deterministic. Prompts and sampling are pinned so runs reproduce; a proven plan becomes a replayable template.

How it actually works — the technical spine

Under those six commitments is a concrete architecture. The pieces a systems engineer will care about:

• Capability-dispatched orchestration. There is no hardcoded A→B→C. Each unit of work is a plan step that declares the capability it needs, the inputs it depends on, and the output it produces; the orchestrator schedules every step whose dependencies are met onto any agent advertising the matching capability — routing is dispatched from an agent registry by declared intent, not a switch statement. Register an agent, declare what it handles, and the router finds it; nothing gets rewired.
• A typed hand-off envelope. Agents never pass raw strings. Every value crossing a seam is a validated object carrying (value, confidence, source). The confidence drives the act-vs-confirm decision; the source is what makes the next guarantee possible.
• Field-level provenance verification. After each step, a guard checks that every field in the output traces back to something in that step’s input. A date that appears with no source is flagged as a hallucination even when it happens to be correct — because a right answer from a broken derivation is the failure mode that scales silently.
• Determinism where it counts. System prompts and sampling parameters (seed, top-p, top-k) are pinned per agent so runs reproduce; a plan proven once is saved as a replayable template — known asks replay deterministically while novel ones get dynamic scheduling.
• A three-primitive ontology. My whole life reduces to three objects — a condition, a time-block, and a to-do — and their compositions. An event isn’t a fourth type: it’s a to-do nested in a time-block, so it inherits a completion state, sub-activities, and a stable identity across recurrence for free. Get the primitives right and one rule — a condition that watches a to-do’s done-state and releases its block — reaches every feature instead of being special-cased a dozen times.

• Attribution — the system measures its own autonomy. Because Claude currently writes the code and the local swarm does the reasoning, every executed step is stamped with a plan-time verdict and an executor mark, and those roll up into a self-sufficiency score: an honest, tracked measure of how much Witan did on its own versus how much still needed the frontier model. The explicit engineering goal is to watch that number climb — the project isn’t “use AI,” it’s “remove the outside dependency, measurably, over time.”

Key capabilities

As of July 20, 2026 — each segment page below carries the depth.

• Capture from anywhere, normalized into one stream — including autonomous email capture that can never mistake a third party’s words for my instructions.
• Wearable and financial data ingestion: recovery, sleep, and strain from a wearable and accounts and transactions from a financial pipe flow into the same graph as everything else.
• An attention gate that scores any inbound for interrupt-grade importance and decides push-now versus hold-until-you’re-free.
• Plain-language calendar and to-do control with guardrails: meaning-based routing, bulk operations, per-item confirms, undo on everything, and a grounding gate that refuses known-wrong actions outright.
• IF/THEN conditions over the schedule that derive, cascade on change, detect conflicts (including timezone-vs-sleep), reason about whole travel days, and propose fills for freed time.
• Location and vision awareness: an event’s address becomes a real place with drive-time and leave-by math, and a photographed schedule is read by OCR and grounded onto the right events.
• Answering questions from my own record — a retrieval pass searches my stores and replies with provenance, not from the model’s memory.
• A printed morning brief by ~04:30, delivered to an e-ink notebook — and my handwriting on it flows back in as structured, routed decisions.
• Full-depth observability: every agent run traced with verbatim I/O, explainable in one tap, summarizable in plain language. The dashboard never dresses a default up as a measurement.
• A learning loop: every evaluation becomes a durable labeled training example; nightly regression replays pin the prompts; challenger models must beat incumbents on my real prompts to win a seat.
• A self-tending fleet: wedge detection and prediction, durable model supervisors, and an escalation path that can convene the Mac minis into one larger machine.

Coolest things it’s done

• Taught a local model by building. The newest program: when Claude (the system’s builder) implements a feature, it now decomposes the work into atomic, ≤50-line steps — each written up as a task card a 9B-class local model could take: the ask in six lines, the exact context, the constraints, and the diff actually produced. A local code model then attempts the same steps, and the deltas between its output and the reference diff drive prompt and harness changes. The build process is the training curriculum — Claude isn’t just constructing Witan, it’s teaching a small model to do the constructing.
• Closed a planning loop on day one. The gap-filler shipped, noticed the week’s empty stretches, proposed ranked uses with plain-language receipts (“why this block exists”), and placed the approved blocks — proposed, approved, placed, live, the first day it existed.
• Refused correctly. The catalog-grounded gate’s whole purpose is saying no: “complete the event” when the thing is a to-do gets asked about, not guessed. The wrong-asset failure class was eliminated as a class — and an adversarial test battery pins it shut.
• Made paper a two-way interface. A printed page with pen marks on it comes back as structured decisions that route and execute. The e-reader even carries a live mirror of every agent’s actual system prompt — observability that doesn’t stop at the dashboard.
• Chose not to upgrade. A model-refresh bench replayed real captured prompts side-by-side against challenger models, and the incumbent 8B kept its seat. The upgrade that didn’t happen is the evidence system working.
• Reasoned about a whole travel day. Given a trip, the system now reasons across the day — whether a tight flight connection survives, what that implies for the blocks around it — and surfaces one grounded heads-up instead of a pile of disconnected calendar alerts. Consequence-reasoning moved up a level, from the single event to the day.

What it can’t do yet

• Write its own code. Witan diagnoses its capability gaps and files scoped build-tasks, but Claude does the building. The mimicry program above is the deliberate, measured path toward changing that.
• 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. Half principle — no wild false moves — and half honest capability limit.
• Absorb a new life domain on its own. Every new class of ask still needs a capability built for it. The ratchet is real but hand-cranked.
• Do the genuinely hard reasoning locally. Some tasks still exceed the small models and climb the escalation ladder. A persistent need for the top rung gets counted honestly as evidence against the thesis for that task class.

How it’s built

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, merge review, and this portfolio — coordinates over Witan’s own message bus, each lane under 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 batteries pin the safety boundaries, and a version chip on the dashboard proves what’s actually running.

Why a custom harness

The obvious question: why not stand this up on an off-the-shelf assistant harness — OpenClaw, Hermes, a LangGraph-style agent stack — and save months? Three reasons, and one honest cost.

• The harness is the product. Those frameworks put a capable model at the center of a big loop and surround it with tools, skills, and memory. That gets you capability fast — but the reasoning stays inside the rented model, and you can’t instrument what you can’t see. Witan’s load-bearing walls — typed contracts at every seam, lossless verbatim I/O, field-level verification, learning from corrections, deterministic replay — aren’t plugins you bolt onto someone else’s loop. They are the architecture.
• The research question demands ownership. “Can composed small local models rival a frontier model on bounded personal tasks?” is only answerable if you control routing, scheduling, model placement, and every trace. On a framework, you’d be answering a different question: “how good is the framework’s model?”
• Local-first is below the abstraction line. Privacy is non-negotiable — my life’s data stays on hardware I own — and running always-on inference across a fleet of Mac minis means living with thermal limits, wedged servers, memory ceilings, and model supervision. General frameworks abstract exactly the layer where this project does its most important work.
• The honest cost: we pay for it in infrastructure. The wedge program exists because we own serving. Queues, gates, supervisors, benches — things a framework hands you — get built by hand here. Feature velocity is slower than a big-model loop would be. That trade is accepted on purpose: the harness knowledge is the expertise being built.

Where it’s been hard

The struggles are documented as deliberately as the wins, because the failure classes are the curriculum:

• Silent loss is the worst defect class. A typed thought that vanishes without acknowledgment is worse than a crash — you don’t know it happened. The fix became a design rule across the system: transactional sends, visible drafts that survive an app kill, and “a visible duplicate always beats a silent loss.”
• Defaults masquerading as data. The reasoning trail once stamped 0% confidence on every step — not measured, just the storage default rendering as a number. In an observability product, that’s poison: the moment a default looks like a measurement, every real number loses credibility. Unmeasured now renders as nothing.
• Capability is not usage. A verified intake upgrade sat unexercised for a day because its trigger never arrived. Dashboards that show what a system can do say nothing about what it did do — first-live-exercise is now watched explicitly.
• Context hygiene at session boundaries. The most damaging failure mode all month wasn’t a model being dumb — it was an agent confidently describing a machine that doesn’t exist, built from stale context. The fix was structural, not clever: canonical docs that outrank memory, a fixed boot reading order, and a state-snapshot ritual before every reset.
• Always-on local serving fails in new ways. A model server can be alive but wedged — up, answering health checks, doing nothing. That discovery became a whole reliability program: on-node guards, a central backstop, an incident log, and a predictor that flags a machine likely to wedge before it does.

Development log

Family-wide milestones live here; each segment page keeps its own log.

Week of July 16 – 20, 2026

Around 130 changes merged. The theme: the system reached out to the real world — wearable and financial data — and closed the last gaps in its own observability.

• Health and Finance stopped being placeholders. A wearable pipe now streams recovery, sleep, and strain into Witan; a financial pipe pulls in accounts and transactions; and a new fitness layer logs body metrics, labs, and an Army fitness-test scorecard, with a workout trainer that turns those numbers into gap analysis and a grounded training week. Both Health and Finance graduated from “early” this week.
• Observability closed its own gaps. Tools — not just agents — are now first-class Cortex nodes (the last observability invariant, restored), and attribution reconciled to complete coverage: every observed run attributes, nothing undercounts. That matters because the self-sufficiency score is only honest if nothing is invisible.
• An attention gate. Any inbound now gets an interrupt-grade importance score, and a gate decides push-now versus hold-until-you’re-free — the difference between an assistant that respects your focus and one that just pings.
• Witan started writing its own docs. Corrections now flow into living documents the system authors and maintains — the correction-becomes-durable-knowledge loop, pointed at its own documentation.
• The paper loop learned to read. The e-ink brief can now read pen-marks back through per-box vision crops, and an approved Boox card executes exactly once — the analog-in path is genuinely closed.

Next: turning the new health and finance signals into propose-only guidance (a hard recovery week reshaping the day; a renewal surfaced before it hits), and the first real captured Cortex traces feeding this site’s live demo.

Week of July 8 – 15, 2026

A heavy week — roughly 180 changes merged. The theme: Witan got a cleaner model of the world and started reasoning at the level of a whole day, not a single event.

• A unified ontology. Everything collapsed to three primitives — condition, time-block, to-do — with an event redefined as a to-do nested in a time-block. That one modeling decision gives every action a completion state, sub-activities, and a condition that can watch it and release its time. See the technical spine above.
• Consequence reasoning moved up to the day. A new day-level semantic cascade reasons about travel days — flight-connection survival and what it implies for the surrounding blocks — and emits one grounded card instead of a flood.
• Location and vision became real — a new segment: addresses geocode to places behind a swappable map seam, drive-time gets a real floor, a reverse leave-by/wake-by/prep cascade runs propose-only, and a photographed schedule is read by OCR and grounded onto its events.
• Email got a doctrine. The always-on inbox scan was retired in favor of a label-gated evaluator — you decide what Witan is allowed to reason about, and a labeled message fires the propose-only pipeline at the door.
• The system can answer from its own record — a retrieval pass searches my stores and replies with provenance instead of the model’s memory.
• Two security and safety hardenings: approved cards now execute server-side rather than through an agent shell, and a before-state now rides every mutating action so undo is a true invariant, not a feature.
• The build measures itself. Attribution landed — plan-time verdicts, executor stamps, and a self-sufficiency score tracking how much Witan does without the frontier model. The whole documentation tree also got a nightly drift-check that grades files against reality.

Next: wiring the ontology’s completion→release loop end-to-end, deepening the location cascade, and the first interview-to-writing flow from Witan’s own Portfolio surface into this site.

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 — 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.
• This portfolio became a lane. The projects family you’re reading was restructured — one WITAN parent, in-depth pages per segment — and a weekly update loop now keeps it honest.

Next: the portfolio surface inside Witan itself (structured fields for the current book and projects that feed this site, plus an interview mode whose transcripts become blog drafts), deeper multi-step flows, and richer memory over the labeled corpus.