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 September 13, 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.
• Class packs. A raw planning input — an itinerary, a syllabus, a tasking order — is classified and routed to a pack: a schema, a doctrine, and a compiler built for that one class. A single big-context model pass does extraction, policy, and nuance; the pack’s compiler does every clock in code. Packs generalize within a class and decline honestly outside it.
• Asking, and hearing the answer. A planning pass can pause as waiting on me, raise up to three genuinely-blocking questions, and carry my answer into every subsequent pass. An ask ladder decides who answers first — a place lookup, then the web, then my own records, and only then me.
• 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.
• Outbound on the right channel. Witan can send a message, speak, and take a planning call — with hard guards: a reminder can never be talked into becoming a sent message, and the model may read who I meant but never supply someone I never named.
• Self-hosted web search. No cloud search keys anywhere in the system: a self-hosted provider, an injection-hardened fetcher, a gated deep-dive, and an honest error rather than a silent empty answer.
• Two-way calendar projection. Plans project to real calendars by rule rather than by occurrence, and an event Witan no longer holds cannot survive there as a ghost.

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.
• Audited its own memory and published the verdict. I checked the memory architecture against production instead of against its own documentation, and it failed: the note graph was effectively write-only, recall had one caller, no model prompt actually consumed a recalled memory, and embeddings were off — so every “semantic” search in production was keyword matching. What was learning my preferences turned out to be a handful of prompt and deterministic loops living entirely outside the memory system. That finding is the most useful thing the project produced that month, and it’s in the log below rather than buried.
• 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.
• Remember, in the way the word implies. Records and labeled examples accumulate, and a memory layer exists — but a September audit found it write-only in production: stored, not retrieved, and not reaching any model’s prompt. The layers are built; the last mile isn’t wired. This is currently the top of the build queue, and it is stated here as a limit rather than a feature because that’s what it is.
• 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 pack built for it — schema, doctrine, compiler, bench. The pack architecture makes each one cheaper than the last, but the ratchet is still 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. Through the first half of 2026 that meant a team of role-scoped Claude instances — a router/manager triaging every ask, plus dedicated lanes for agents, UI, ingestion, fleet substrate, the morning brief, merge review, and this portfolio — coordinating over Witan’s own message bus, each lane under a written charter.

That structure was retired in August. Lane coordination had started costing more than the parallelism returned: charters drift, every handoff sheds context, and a router in front of every ask is one more place for a stale picture of the system to enter. It collapsed to a single builder with full access to the whole repository — simpler, and more honest about where the leverage actually sits. It was never the org chart; it was the contracts and the gates. Throughout both eras I stay in exactly one seat: the only approver, and the only one who deploys.

Three rules bind the work, and outlived the reorganization:

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.

Weeks of September 1 – 13, 2026

Roughly 190 changes. The theme: Witan learned to ask me a question — and got an honest verdict on its own memory.

• Planning became pack-shaped. Rather than one general planner guessing at every input, a classifier routes a raw document to a class pack: a schema, a doctrine, and a compiler built for that class alone. One big-context model pass does extraction, policy, and nuance; the pack’s compiler does every clock in code, because a model should never be trusted with arithmetic it can fake. The first pack — travel — went live in production behind its own routing without flipping the global engine, and was certified against a real trip. Eight more are ordered behind it: school, someone else’s travel, work projects, client calls, hosting, service windows, life admin, habits.
• Witan can ask, and can finally hear the answer. The planner had questions and no way to voice them. A pack could raise one, but only as un-answerable text on a plan card — and on a re-run it re-read my original sentence and ignored everything I’d said since. Both halves are closed: a pass can now pause as waiting on me, mint a real question card, and carry my deposited answer into every subsequent pass. An ask ladder decides who answers first — resolve it from a place lookup, then the web, then my own records, and only then interrupt me, capped at three questions and critical ones only.
• An honest audit of the memory system. I audited the memory architecture against production instead of against its documentation. It failed. The note graph was effectively write-only: most stored notes unreachable by any reader, one caller for recall, and no model prompt anywhere actually consuming a recalled memory. Embeddings were off, so every “semantic” search in production was keyword matching. What was learning my preferences turned out to be a handful of prompt and deterministic loops living entirely outside the memory system. Fixing it is now the top of the queue — and the audit is logged here rather than quietly absorbed, because an observability project that won’t audit itself is just a dashboard.
• Retrieval learned vocabulary. Asked about “the hotel” on a trip, Witan returned nothing: my records name things — a property’s brand name — while my questions categorise them. Category-to-instance resolution landed, along with statement-shaped asks (not every question ends in a question mark), a guard against a stale digest answering a live question, and a leak where a question about my own records could reach an external search provider.
• Two clocks, and nothing ever set the second one. The app carried a house timezone and a separate notion of where I actually am — the one that drives every day boundary — and nothing had ever written the second. Every day boundary ran hours off while travelling. The class lesson is the useful part: the moment a constant becomes runtime-settable, every default derived from it goes quietly stale.
• The dashboard’s front page, redrawn by hand. I sketched the tile layout I actually wanted and the home screen was rebuilt to it — three rows, no headers, seven tiles I never open moved to an “unsorted” shelf. Messages became a bar that surfaces what the screener already flagged and refuses to poll, because polling an observability endpoint writes a trace row every single time.

Next: memory the planner genuinely reads, the school and goal/weekly-planning packs, and Witan placing the call — initiating a conversation about the week instead of waiting to be opened.

Weeks of August 18 – 31, 2026

The heaviest stretch of the year — roughly 225 changes. The theme: the system learned to read a long document and plan out of it.

• A planning input became a first-class object. A syllabus, an itinerary, a tasking order now enters as a durable unit of work that gets oriented, sliced into parts, and worked step by step — each step’s arguments derived, checked, and staged rather than pattern-matched out of a sentence. Most of the month went into the unglamorous half of that: an anchor is a moment the input states, never one the model supplies; a derived time converts once, after its zone is final; a staged day has to be physically possible; a typed date range must name this unit’s real days, in order; one module can’t be staged twice under two different phrasings of the same dates.
• Refusals that steer. A pass that can’t proceed no longer just fails — it hands back the concrete next call it would need, so the loop can often answer itself instead of stalling on me. A refusal became a form of routing.
• Calendar projection stopped lying in both directions. A recurring event hands the calendar its rule, not one of its occurrences, and an event Witan no longer holds can’t survive out there as a ghost. The mismatch where Witan holds a block the calendar doesn’t turned out to be the more dangerous half.
• The document budget was the ceiling, not the model. My longer documents were being cut roughly in half before anything read them. Worth remembering when a model “misses” something.

Weeks of August 4 – 17, 2026

About fifty changes, most of them structural rather than visible.

• The calendar became budget-first. The time-block model landed: blocks with real capacity, strict domains, per-task buffers, automatic titles, conditions that carry effects, and a scheduler that fills a gap rather than complaining about it. Regex scheduling semantics were replaced outright by a deliberation engine — condition elicitation, assumption discovery, honest provenance on every placement, and an explicit budget for how much it’s allowed to ask.
• One database. Every sidecar store migrated onto a single primary database at boot, with foreign keys on, a defined contract for ad-hoc runs, orphan cleanup under a standing audit, and retention and garbage collection on the heavy tables. Boring, and the highest-leverage work of the month.
• Witan can send — carefully. “Text my wife X” reaches the send machinery instead of quietly becoming a to-do. Three guards ship with it: a reminder can never be talked into becoming a sent message; the model may read who I meant but can never supply someone I never named; and handles normalize so the message actually lands. Proactive voice and a call tile arrived alongside.
• Search came home. Web search moved to a self-hosted provider — no cloud search keys anywhere in the system — with an injection-hardened fetcher, a gated deep-dive, and an honest error instead of a silent empty answer.
• The build team dissolved. The lane structure described above was retired this month in favour of a single builder with full access. See “How it’s built” — the rules survived; the org chart didn’t.

Weeks of July 21 – August 3, 2026

Around sixty-five changes. One theme, pursued hard: making the system’s own claims checkable.

• One verified seam for every model call. Every LLM call migrated onto a single verified helper, retiring a dozen clones that had been bypassing it. Harness identity was stabilized end-to-end so a verdict attributes to a specific harness, and verdict integrity was fixed. A learning corpus is worth exactly as much as the identity stamped on its rows.
• The honesty program. A cluster of defects turned out to share one shape: the system claiming something it hadn’t verified. A store outage now renders as “couldn’t check,” never “you’re clear.” A channel with no adapter is never marked sent. A delivery isn’t a delivery without transport confirmation. A failed read shows amber “unknown” instead of a confident zero. Seeded test data can’t poison production telemetry. The false all-clear is the one wrong answer this system is not allowed to give.
• Every run banks the prompt it actually saw. A content-addressed blob store captures the verbatim system prompt behind every run, so a training example resolves to what the model really received — not what the code currently claims it would send.
• The training ratchet got its stages. A per-harness dataset assembler over the labeled corpus, a trainer stager, and a graduation eval-gate a candidate model has to pass before it can take a seat.
• A security pass. Upload endpoints name files server-side, closing a path-traversal hole, and a poison item in the verification queue parks after N attempts instead of head-of-line blocking the whole drain.

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.