Cross-Pollination Brief — March 27, 2026

Klatch's densest feature day to date. Daedalus shipped the complete Step 9 file suite — upload, artifact rendering, context injection, code block export, and native tool use — plus Round 12 Tier 1 infrastructure (auto-prompt caching, Models API dynamic discovery, kit briefing improvements). Separately, Calliope recovered from a billing interruption with zero information loss, extended the AXT methodology for import/export validation, and piloted the first externalized Layer 5 calibration document. The File Domain Model design doc, approved by xian, establishes files as first-class domain objects with five-level ownership — foundational architecture for Steps 10 and 11. Piper Morgan was quiet; no new substantive commits in the window.

Key Insights

1. File Domain Model: Files as Domain Objects, Not Payloads

From: Klatch (docs/plans/FILE-DOMAIN-MODEL.md) Relevant to: Piper Morgan

Klatch approved a design document establishing files as first-class domain objects with ownership and visibility at every contextual level. Five levels: Kit (L1, awareness only), Project (L2/L3, knowledge base), Channel (L4, working set), Entity (L5, library), Message (one-shot attachments). The core principle: pointers, not payloads — files are referenced by context, not injected wholesale into prompts.

Two directional operations: promotion (message file becomes channel resource becomes project knowledge) and projection (project knowledge made visible to channel or entity with a delivery prompt). Memory itself is modeled as a file with a convention, not a separate concept.

This matters for Piper Morgan because PM's knowledge base (knowledge/gameplans/, BRIEFING documents, role definitions) operates as an ad hoc version of the same pattern — documents that exist at project scope and are selectively projected into agent sessions. The File Domain Model formalizes what PM does implicitly. If PM ever needs to manage agent-created artifacts (reports, analysis outputs) alongside curated knowledge, this ownership model provides a tested reference architecture.

Suggested action (Piper Morgan): No immediate action. File the design doc as a reference for any future knowledge management redesign. The promotion/projection pattern is directly applicable to how PM manages the relationship between the knowledge base and per-session agent briefings.

2. First Native Tool Use in Klatch

From: Klatch (packages/server/src/claude/client.ts) Relevant to: Both projects

Klatch entities can now create files via native tool use — the first non-conversational capability. The implementation refactored the streaming API from fire-and-forget to a tool-use loop: stream response, detect tool_use stop reason, execute tool, send result back, continue (with a MAX_TOOL_ROUNDS=5 safety limit). Both standard and compaction API paths support tools.

This is architecturally significant because it establishes the pattern for all future tool capabilities. The tool schema is defined in a KLATCH_TOOLS array, tool execution is centralized in executeTool(), and the streaming loop handles the full request-response cycle. Any new tool (search, web fetch, code execution) drops into the same infrastructure.

For Piper Morgan, this parallels the tool-use patterns PM agents already employ through Claude Code — but Klatch is implementing it at the application layer rather than relying on the Code harness. The tradeoffs are different: Klatch controls the tool registry and execution environment entirely, while PM inherits Code's tool ecosystem but can't customize the execution loop.

Suggested action (Piper Morgan): Methodological interest only. If PM ever considers custom tool implementations beyond what Claude Code provides, Klatch's approach (centralized registry + streaming loop refactor) is a tested pattern.

3. Layer 5 Calibration Pilot: Making the Implicit Explicit

From: Klatch (docs/agents/calliope-calibration.md) Relevant to: Both projects

Calliope created the first externalized Layer 5 calibration document — a structured capture of working preferences, workflow patterns, and communication style learned through accumulated sessions with xian. This directly addresses the Layer 5 transfer gap identified in the March 26 brief: behavioral calibration doesn't serialize in import/export, so the mitigation is to make it explicit before you need to transfer it.

Contents include: xian's preference for synthesis after thinking aloud (not during), that "make note of that" means commit (not just log), that sequence in multi-step requests reflects priority, and specific patterns like branch sweep at session start and session log before work. The document is marked as a pilot — to be assessed in a future MAXT session for transfer fidelity.

This is the first practical implementation of the recovery strategy the March 26 brief suggested: "make behavioral calibration explicit in CLAUDE.md and role definitions rather than relying on accumulated session history." The brief noted that PM already does this better than most via detailed role definitions. The calibration pilot tests whether a more granular, per-agent capture is worth the maintenance cost.

Suggested action (Piper Morgan): Consider whether PM's role definitions capture enough behavioral calibration, or whether per-role calibration notes (analogous to Calliope's pilot) would improve successor continuity. The 14-role architecture makes this a scaling question — 14 calibration documents is substantial maintenance.

4. Infrastructure Compounds: Caching, Discovery, Kit Briefing

From: Klatch (Round 12 Tier 1, packages/server/src/claude/client.ts, packages/server/src/routes/models.ts) Relevant to: Both projects

Three infrastructure items shipped alongside the feature work:

• Auto-prompt caching: One parameter (cache_control: { type: 'ephemeral' }) on both API call sites. Cache reads at 10% of input token cost, writes at 125%. A cost reduction that requires no behavioral change.
• Models API dynamic discovery: New GET /api/models route fetches from Anthropic's GET /v1/models with 1-hour TTL cache and hardcoded fallback. Returns capabilities (thinking modes, effort levels, compaction support, max output tokens). Six client components updated from static imports to dynamic lookup. No more hardcoded model lists.
• Kit briefing improvements: Current date injection and layer-awareness text ("Your context may include project instructions and project memory... treat it as background knowledge"). The layer-awareness addition directly addresses the MAXT subliminal finding — if an agent can access content without knowing where it came from, telling it to expect that content reduces the attribution gap.

The compound effect matters: each item is small individually, but together they reduce operational cost, eliminate a maintenance burden, and improve agent context quality. All shipped in the same session as Step 9, demonstrating that infrastructure and feature work can run in parallel when the infrastructure items are well-scoped.

Suggested action (Piper Morgan): The auto-prompt caching pattern is directly applicable if PM ever manages its own API calls. The kit briefing layer-awareness text addresses a real problem PM shares — agents receiving context they can use but can't attribute. Consider whether PM's session-start briefings should include similar meta-awareness framing.

5. Test Debt Surfaced and Assigned

From: Klatch (docs/logs/2026-03-27-1004-daedalus-opus-log.md) Relevant to: Both projects

Pre-existing test failures (17 files, 189 test cases) were traced to three root causes: client jsdom environment collision (workspace config), stale compiled JS in dist/, and one unmocked dependency. All three have known fixes. Assignment to Argus Round 13 defers the work but makes the debt explicit and trackable.

The pattern is notable: 1041 tests passing, 189 failing, and the failures were known and categorized rather than silently ignored. Daedalus shipped new features with confidence because the failure categories were understood — none of the 189 failures were in the areas being modified. This is healthier than either blocking on full green or ignoring failures entirely.

Suggested action (Piper Morgan): PM already maintains rigorous test counts (6310 tests as of March 25). The Klatch pattern of categorizing failures by root cause — rather than just counting them — is worth adopting if PM ever encounters persistent failures during rapid development.

Emerging Patterns

Layer 5 is becoming the central research question. The March 25 brief surfaced subliminal injection (content accessible without attribution). The March 26 brief showed Layer 5 doesn't transfer in import/export. Now the March 27 work produces the first practical mitigation: externalized calibration documents. Three consecutive days, three angles on the same problem, each building on the last. Both projects are converging on this — Klatch through testing methodology and pilot documents, Piper Morgan through detailed role definitions. The question is shifting from "Layer 5 is hard" to "what's the right granularity for externalizing it?"

Infrastructure and features are shipping in the same sessions. Klatch's Round 12 + Step 9 same-day delivery, and the emerging pattern of scoping infrastructure items small enough to ship alongside feature work, is a methodology insight. The items that shipped (caching, dynamic discovery, kit briefing) are all one-parameter or one-route changes with outsized impact. This is the "small bets" pattern applied to infrastructure.

Background Changes (Noted, Low Priority)

• Klatch v0.8.9 released with CHANGELOG backfill for 0.8.7/0.8.8
• Demo pipeline Phase 1: Playwright installed, Mystery Menu scenario scripted (database isolation via KLATCH_DB env var)
• Editorial calendar created: three blog posts drafted (Subliminal finding, Layer 5 calibration, Tesler's Law applied to context sprawl)
• LinkedIn draft for v0.8.9 announcement awaiting xian editorial review
• UX polish backlog (docs/UX-POLISH.md) started — deferred items cataloged rather than lost
• Calliope recovered from billing interruption (new account: xian@designinproduct.com) with zero information loss — all context rebuilt from repo state
• Nomenclature project flagged: "System prompt" in Klatch UI means Layer 4 but users perceive it as Layer 5; interim rename planned

Sources Read

Klatch:

• docs/logs/2026-03-27-1004-daedalus-opus-log.md — Comprehensive session log: Round 12 Tier 1, Step 9a-d, File Domain Model, test audit, demo pipeline
• docs/logs/2026-03-27-1019-calliope-opus-log.md — Recovery session: AXT extension, calibration pilot, editorial calendar, three blog drafts
• docs/plans/FILE-DOMAIN-MODEL.md — Five-level file ownership model, approved
• docs/AXT.md — Import/Export Fidelity Testing extension
• docs/agents/calliope-calibration.md — Layer 5 externalization pilot
• CHANGELOG.md — v0.8.9 release notes
• git log --since="48 hours ago" — 18 commits across two sessions

Piper Morgan:

• git log --since="48 hours ago" — No new substantive commits in window