← Briefing Room

Tend — Module 1 Build Plan

Internal2026-08-13 · From Thomas's voice directive + MODULE-MAP repo audit + BETTER-THAN-GPT analysis

Milestone 1 — the target state

Functioning chat at the daily-driver bar + 3–4 connectors that work super smoothly + a solid, autonomous data-layer management system.
  1. Chat — all current capabilities ported, agent identity + behavior carried whole, polished, latency fixed
  2. Data layer built through chat — agent extracts data-layer-worthy info, proposes MD docs → approve/edit → auto-filed; wiki-linked file tree that reads intuitively; autonomous background maintenance; one small approval surface
  3. Connectors — Gmail + 2–3 others, super smooth, living in/near the data layer
NOT in Milestone 1: sandboxed exec, browser automation, mini-apps (M2), automations UI (M3), team workspace, voice. Multi-model harness: one slice ships (review passes), the rest designed-for, built later.

Phase 0 — The cut

Lock with David before code:

DecisionRecommendationWhy
Where the side app livesNew app in the same monorepo (apps/solo) — a second web client of apps/applicationShared contracts/types/CI; the application layer is already the web↔agent seam. Fresh repo re-solves auth, types, deploy for zero gain
ShareDB + RLS · auth + agent-JWT · agent runtime + fleet · connector engine · retrieval · job queueThe mass and the moat; re-implementing any is wasted cycles and re-opens solved safety surfaces
Fork freshWeb shell chrome, chat surface chrome, the entire /data + attention UXThis is where "under-perfected" lives; contracts stay identical so the fresh UI drops onto existing routes
FreezeTeam Hub, /map, /pipeline, /outputs, /workflows, voice, billing navCode stays, nav dies. No deletions in Phase 0
Output: scaffolded apps/solo shell rendering against live routes.

The Phase-0 decision — same monorepo vs fresh repo

✅ DECIDED — same monorepo. Signed off by Thomas, Aug 13. apps/solo proceeds as a second web client of apps/application. Phase 0 is unblocked.
Same monorepo (apps/solo)Fresh repo
How sharing worksDirect imports: DB + RLS, auth + agent-JWT, agent runtime, connector engine, retrieval, job queue, typed API contractsEverything shared becomes an over-the-wire API or copied code; the application API isn't published as a stable external contract today — that would have to be built first
Spine improvementsLand in both apps automatically — one fix, two clientsDouble-ship every change, or maintain a versioned SDK — pure tax at our team size
Type safety / driftCompile-checked against the live API; drift impossibleContract drift guaranteed without published packages + version discipline
CI / deploy / secretsExisting pipelines and previews just workSecond pipeline, second secret store, second deploy story — day one
Speed to first renderScaffold + point at live routesRe-solve auth, env, contracts before the first screen renders
Clean-room feelMust be engineered: import boundary + shell starts emptyFree — nothing old in sight
Spin-out opticsWeaker separation; extraction later is real work if solo becomes its own companyClean separation from day 1
Strangler fitExactly the pattern: strangle the old shell, keep the organsTakes the organs out of the body — the opposite of the strategy

The call: same monorepo. The only genuine fresh-repo arguments are psychological (no gravity) and corporate (spin-out optics). The first we get with a lint-enforced import boundary (apps/solo may import packages/*, never apps/application UI) and an empty shell where components earn their way in; the second isn't a Milestone-1 problem — extraction is possible later if solo earns it. Everything else — sharing, drift, CI, speed — points one way.

Phase 1 — Chat port + polish

Port, not build — chat is the best-built surface in the repo

Port list (steal as-is, recut chrome)

  • Chat core: Composer, Messages, SurfacePane, sidebar, SSE stream w/ resume, attachments, typed blocks, stop/cancel, projects
  • Agent runtime unchanged (shared): tool loop, plan/verify, subagents, model retry
  • Agent identity + behavior carried whole: prompt law, tone work, memory tools, mode catalog minus the librarian persona
  • Skills (9 seeded), deep_research, doc/PDF generation, connector tool-use

The polish pass

  • Latency is item #1 — p50 first-token 5.6s vs 2.5s target; prompt-cache flip dark; verify pass holding ~4s. Without this, "as efficient as current chat" fails
  • The solo shell starts empty — components must earn their place
Exit bar: daily chat work in the fresh shell feels equal-or-better than the current app — measured by us using it daily.

Phase 2 — Data layer v2: chat builds it

2a · The core mechanic

Extraction → proposal loop

Exists: inline proposal cards from main chat, generalized proposal spine, write-through rail. Build: a data_file proposal variant · the proactive trigger (agent notices data-layer-worthy info mid-conversation, proposes a drafted MD doc) · inline edit in the card · approve → auto-filed with provenance.

2b · Behind the scenes — pattern: the wiki memory system we already run internally

The wiki engine (autonomous maintenance)

StageJobSubstrate
CompileExtract entities/structure from new docs + conversationsLibrarian scan passes — persona removed, jobs kept
LinkPropose wiki-links between related filesEntity graph + graph retrieval exist; link-proposal pass is new
LintDedupe, contradiction detection, staleness → attention queueConsolidation + dedup exist; contradiction write-path is the known gap (seam reserved)
SynthesizeMerge fragments into coherent docs, propose restructuresNew pass, same proposal rail

Everything flows through the same approval rail — the user never sees "the system," only proposals and a clean tree. Runs nightly + on-ingest.

2c · The feel

Browsing your own well-kept files

  • One polished file tree + renderer: logical structure, click → beautifully rendered MD with working wiki-links, peek, edit-in-place
  • One small attention surface on top: approve / deny / edit / reconcile, over the live attention feed
  • Seeded business ontology — starter tree shaped for operators (company / people / products / processes / decisions / reference) so day-1 filing lands somewhere logical
Exit bar: a week of real use grows a data layer that reads like a well-kept wiki, with ≤ a handful of sensible approvals surfacing per day.
2d · Design-for-later — zero build now

Held decisions

  • Shared company layer: N personal layers → one company layer later. Cost now: namespace paths + entity IDs per-user, keep the link graph mergeable. Decision only, no code
  • Multi-model registry: design the per-task provider slot in the inference package; wire only the review-pass slice

Phase 3 — Connectors, few and flawless

Engine exists and is mature (16–17 connectors, OAuth, freshness, grant-health, write-safety). This is selection and polish, not build:

Milestone 1 acceptance — three tests

  1. The benchmark (from BETTER-THAN-GPT.md): 12-task battery vs ChatGPT Business + Claude on the same seeded corpus, blind-scored. Hard gates: zero fabricated company facts, zero losses on ground-truth / multi-session tasks
  2. The compounding test: after 2 weeks of daily use, the data layer answers questions it couldn't at day 1 — without anyone manually filing
  3. The install test: this exact build is what a 45-day install sprint deploys — module 1 and the consulting install are the same object (canon §9)

Agent doctrine — Thomas's "better than GPT" answer

"We beat everything that exists by using everything that exists in the best possible way."

The best-of-everything harness

  • Multi-model by task: Opus/Claude main driver · GPT review passes on big analyses (a second model kills bias and catches drift — two models on one task always beat one) · Grok subagents for X/trends · best-in-class per capability (image gen, voice later, deep browsing APIs, social APIs)
  • Best-tool harness: for each capability, find the best API/tool in the market and bake it in; add skills where no tool exists
  • Structural edge: no single-LLM company can offer this — composition is exactly what they can't do
  • In this plan: the inference layer already routes multi-model — extend to a per-task provider registry. Milestone 1 ships one slice (GPT review pass) as proof; every later addition becomes a config entry, not a build

How it composes with the moat: the claim stays "it already knows, and it stays right" — the curated data layer is the substrate no frontier vendor has. The harness is how the agent stays frontier-best at execution. Together: best substrate (their data, curated) × best execution (every frontier capability, composed).

Who does what

WhoOwns
Davidapps/solo scaffold + chat port + latency (Phases 0–1), connector polish (Phase 3)
Rook + agent swarmWiki-engine passes (direct port of patterns we run internally), proposal-loop extension, ontology seed, P2 polish sweeps, benchmark authoring + run
ThomasPhase-0 sign-off · weekly use-it-daily feedback from the first shell onward — the polish bar is judgment, not tickets

Cadence: demo against the milestone bar at every phase exit. Phases are sequence, not schedule — with agents on the build, phase clocks run in hours and days; the chat port is the fastest lane (it's the best code in the repo).