DEC-0016 — Forward Deployed Engineer function & the /fde command

Reversibility: two-way door — a subagent + a slash command are easily changed or removed; doctrine lives only in the agent file, the command points to it.

Context

With Extraction runtime architecture — the moat → Plugin + marketplace packaging — distribution as the agency wedge, built from the canonical .claude/ primitives, all four architecture layers were built end-to-end and packaged as an installable Claude Code plugin. The agent roster covers the what/why (Product Owner), the how/topology (Principal Platform Architect), the repeatable runtime (Platform / Runtime Engineer), and the layer engineers — each of whom owns the depth of one layer (okf / ingestion / extraction / mcp / runtime / design). What no role owned was the breadth between layers: the cross-cutting, cross-layer build work — integration, wiring, glue, the last mile that makes the pieces actually run together end to end — and an honest, verified global read of the whole build (what's real vs. claimed-but-unproven vs. reserved behind a seam). At the user's direction ("we need a world class principal forward deployed agent like what Palantir and Anthropic have to help build Dossier" + "create a /fde command"), two artifacts were created. The role is deployed forward onto Dossier itself — client delivery is already owned by product-owner + platform-engineer + the layer/skill stack; this is a build-side, whole-platform generalist, not a client-delivery role.

Options considered

1. Stretch existing roles — lean on principal-architect for cross-layer coherence and the layer engineers for integration. Rejected: the architect decides topology and consults but doesn't code; each layer engineer owns the depth of one slice and isn't responsible for the seams between slices. No one holds the whole-repo global overview or ships the connective tissue end to end.
2. A heavyweight slash command carrying the doctrine inline. Rejected: duplicates the role definition and breaks single-source-of-truth.
3. A principal FDE subagent + a thin /fde launcher (chosen) — the doctrine lives only in the agent; the command points to it.

Decision

Add the Forward Deployed Engineer function as a new build-side principal subagent, plus the repo's first slash command. Doctrine and command are the source of truth; this record references them (see .claude/agents/forward-deployed-engineer.md and .claude/commands/fde.md).

• .claude/agents/forward-deployed-engineer.md — modeled on the discipline Palantir and Anthropic built ("deploy forward, to where the real problem is, and ship") but the deployment is Dossier itself: it does not embed with clients, it embeds in the build. The hands-on principal generalist who holds the global overview of the whole platform — all four layers (ingest → extract → serve → orchestrate) and every package (@dossier/okf, extraction, ingestion, mcp, runtime, design) plus the agents/skills/hooks and the knowledge base — and moves it forward across every layer. It owns the cross-cutting work that falls between layers: integration, wiring, glue, fixtures, the last mile that makes the pieces actually run together; and an honest, verified global read of the build. It is not pinned to one package, vertical, or client — it roams to where the leverage is. Biased to delivery and ground truth: a green claim it hasn't reproduced is a hypothesis. Tools: Read, Write, Edit, Glob, Grep, Bash, WebSearch, WebFetch; model: inherit — matching the engineer-roster convention.
• .claude/commands/fde.md — the first slash command in the repo (creating the new .claude/commands/ directory). /fde is a thin, ergonomic launcher over the subagent (single-source-of-truth): with a task in $ARGUMENTS → drive it to working, verified code across whatever layers it touches (build it, run it, prove it runs, then route what it learned); with no args → take a global overview of Dossier (the whole repo + the decision log: what's real, what's claimed-but-unproven, what's reserved behind a seam) and propose the highest-leverage next move, ground truth checked not assumed — whole platform, no single project.

Rationale

• It closes the team's missing seam — breadth between layers. Every other role owns the depth of one layer or works at altitude (decide/spec). With six packages and four layers built (Extraction runtime architecture — the moat→Plugin + marketplace packaging — distribution as the agency wedge, built from the canonical .claude/ primitives), the highest-leverage gap is no longer building any one layer — it's making them cohere in code and getting an honest read of the whole. The FDE is the role that holds the whole repo in view and ships the connective tissue.
• Ground truth over claims. The decision log says what was built; the FDE checks what actually runs end to end. A green checkmark it hasn't reproduced is a hypothesis — the role is biased to delivery and brutally honest about reality, the guard against a pile of green checks that don't run together.
• It honors the non-negotiables. Sovereignty + provenance are the things the FDE will not cut for delivery speed (Adopt OKF as Dossier's canonical knowledge format); cross-cutting work is built as Claude primitives where it recurs (Claude-primitives-first build strategy); no fabricated status.
• Thin-by-design preserves single-source-of-truth. The doctrine lives only in the agent file; /fde points to it — no diverging second copy.

Consequences

• The new subagent and slash command activate on the next Claude Code session start (not picked up mid-session) — same as all subagents/hooks.
• The repo now has a .claude/commands/ directory; /fde is the first slash command. Future ergonomic launchers can follow this thin-pointer pattern.
• Boundaries are encoded in the agent (captured here for the record):
  • vs. Principal Platform Architect: the architect decides topology and sequencing and consults — decides, doesn't code; the FDE builds it and reports back what reality says (walks through the one-way doors and says whether the room is what was expected).
  • vs. Product Owner: the PO owns what/why/for-whom/when; the FDE owns getting it built and verified — it doesn't redefine the roadmap, it turns it into running code and feeds back what the build learned.
  • vs. the layer engineers (okf / ingestion / extraction / mcp / runtime / design): they own the depth of their layer; the FDE owns the breadth between layers. It doesn't reimplement their work — it integrates it, exercises it end to end, and hands them precise, reproduced findings when a seam is wrong.
• Build-side role: like principal-architect / platform-engineer / ux-engineer, the FDE is intentionally excluded from the client-facing plugin subset (Plugin + marketplace packaging — distribution as the agency wedge, built from the canonical .claude/ primitives) — an agency runs the loop, it doesn't re-build the platform.

Review

Revisit once the FDE has driven a real cross-layer build to verified code and produced a global state-of-Dossier read that holds up — confirm the role actually closes seams end to end (a cross-package integration that runs, a "green-but-doesn't-run-together" gap caught), that ground-truth verification catches what the log over-claims, and that the boundaries vs. principal-architect (codes vs. doesn't) / product-owner (builds vs. decides) / the layer engineers (breadth vs. depth) hold under real build pressure. Promote to verified once that evidence exists.

Correction (2026-06-14)

Same-day scope correction, at the user's direction, before the role was ever used (stays confidence: asserted, two-way door). The original record — and a now-superseded Update note below — over-applied the literal Palantir/Anthropic "embed with the customer" FDE template, framing the FDE as a client-delivery role (embed with the first agency+client deployment, stand up a client's learning loop by hand, drive Time-to-Live-Wiki). That framing was wrong. The user's intent is an FDE deployed forward onto Dossier's own build: a whole-repo, global-overview, ship-it generalist that advances the product across all layers — not a client role. Client delivery is already owned by Product Owner + Platform / Runtime Engineer + the layer/skill stack. The decision to have an FDE function and a /fde command still stands; only its scope/definition is corrected. The Context, Decision, Rationale, Consequences, and Review sections above have been rewritten to the build-Dossier framing; the agent and command files (.claude/agents/forward-deployed-engineer.md, .claude/commands/fde.md) are the source of truth this record mirrors.

What this corrects, concretely:

• Client-embedded language removed — no "first real agency + client deployment", no "stand up a client's sovereign learning loop by hand", no client-driven "Time-to-Live-Wiki", no "value realized in the field". The FDE is build-side: cross-layer integration, glue, the last mile, and a verified global read of the platform.
• The "be the first three clients → hand to platform-engineer" boundary is gone — replaced by the build-side boundaries (vs. principal-architect: codes vs. decides; vs. product-owner: builds vs. specs; vs. the layer engineers: breadth between layers vs. depth of a layer).
• The role stays build-side and excluded from the client-facing plugin — that part of the original was and remains correct.

Superseded — Update (2026-06-14): /fde dogfood default (REVERTED)

Kept for history; no longer in effect. An earlier same-day Update wired /fde to default to the DXA reference KB as the FDE's first live "client" / proving ground (empty/dogfood/dxa args → a dogfood kickoff against dxa-vertical served via @dossier/mcp), on the dogfood principle. The user reverted this ("I don't want fde to default to dxa dogfood"): the FDE is not assigned to any single project, vertical, or "client" — including the DXA dogfood. /fde with no args is now a global state-of-Dossier overview + the highest-leverage next move across the whole platform (see the corrected Decision above), not a dogfood kickoff. The DXA vertical load that was verified live under that Update (53 atoms / 174 typed edges / 0 load errors / 0 graph errors via @dossier/mcp) remains a true measurement of MCP agentic foundation — tenant-scoped GraphRAG over the OKF KB and is already logged under DEC-0011; it is not evidence for this decision and does not bind the FDE to the dogfood.