DEC-0052 — One loop, three faces: the agentic agency + the adoption ladder

Reversibility: two-way door on the architecture specifics (OKF→persona/runbook/team mapping, coordinator/dispatch, per-tenant fleet isolation, Atrium internals); durable commitment on the product bet itself — an agentic agency grounded in the client's owned, compounding OKF; the Brain+Ladder wedge expanding into the Agency; dogfood-first; delivered through agencies as a force multiplier.

A north-star strategic product direction the user committed to this session. This is a direction-level ADR (the family of Agentic "sprint board" architecture — a git-resident OKF task board worked by bounded, hook-governed Agent SDK loops and Claude-primitives-first build strategy) — it sets the product bet, not a built feature. status: active, confidence: verified — SCOPED to the Agency-face act-and-learn runtime core, promoted 2026-06-20 by inheritance from its ratifying sibling Agentic-agency runtime topology — compile personas from the OKF graph and activate the reserved BoardWorker over the deterministic spine: the Agency loop (dispatch→persona→bounded session→emit→cap→reconcile()→review) ran LIVE end-to-end with all seven invariants enforced, which satisfies the machine-provable portion of this DEC's own Review gate. The promotion is deliberately narrow: the wider "three faces" thesis is not verified by it — the Ladder (the L2 readout is seed-only), the Atrium (unbuilt), the agentic-dashboard surface, and the market / moat / channel thesis (an inherently forward bet, not a claim a single run can verify) all stay asserted / forward work. Distinguish: the Agency runtime core is now a verified build record like The compounding merge — the per-tenant learning loop accumulates by id + confidence instead of overwriting (okf reconcile() + opt-in reconcile in extraction/runtime); the strategic bet around it remains a committed direction.

Context

Dossier has largely built the Brain — the OKF Company Brain that turns a client's messy source material into owned, agent-queryable institutional memory (ingest → extract → OKF → GraphRAG; see MCP agentic foundation — tenant-scoped GraphRAG over the OKF KB and The compounding merge — the per-tenant learning loop accumulates by id + confidence instead of overwriting (okf reconcile() + opt-in reconcile in extraction/runtime)). The strategic question this session: what does the org DO with the Brain, and how does a human ADOPT it? The answer reframes the whole mission as one loop seen three ways, and commits to building the two faces that aren't yet built — sequenced dogfood-first.

This session synthesized that direction against live market signal (recorded under Inspiration provenance below). We are ~80% scaffolded for it:

1. The DXA vertical (verticals/digital-experience-agency/, ~50 OKF atoms; Digital Experience Agency vertical as the first reference implementation) is a digital agency already encoded as knowledge — the team templates.
2. Dossier already runs ITSELF on a 14-subagent team (.claude/agents/) — the dogfood is the current operating model.
3. The plumbing exists: the agentic board (Agentic "sprint board" architecture — a git-resident OKF task board worked by bounded, hook-governed Agent SDK loops) = a work ledger; reconcile() (The compounding merge — the per-tenant learning loop accumulates by id + confidence instead of overwriting (okf reconcile() + opt-in reconcile in extraction/runtime)) = the governance membrane / curation guard; MCP (MCP agentic foundation — tenant-scoped GraphRAG over the OKF KB) = agents' tenant-scoped access to GraphRAG; the Agent SDK = the runtime; the planned "Atrium" live-layer-over-git surface = the co-working room.

The framing — one loop, three faces

The Brain, the Agency, and the Ladder are the same learning loop seen three ways — and they map one-to-one onto the mission's "institutional memory that humans curate and agents extend":

• The Brain — the OKF Company Brain (what the org knows). Mostly built (ingest → extract → OKF → GraphRAG).
• The Agency — teams of agents grounded in the Brain (what the org does; "agents extend"). Runtime core now field-proven (Agentic-agency runtime topology — compile personas from the OKF graph and activate the reserved BoardWorker over the deterministic spine); the dashboard surface + scale are forward work.
• The Ladder — the L1→L14 adoption onramp / diagnostic readout computed from the Brain (how a human adopts; "humans curate"). The wedge; a seed already exists as the per-client KNOWLEDGE-BRIEF.md. Still seed-only (the L2 readout product is unbuilt).

Options considered

1. Stay the Brain (ingest→OKF→serve) only — a memory/GraphRAG product. Rejected: leaves the highest-value half on the table ("agents extend"), and a pure memory layer is easier to commoditize than a memory layer that acts.
2. Lead by out-competing point solutions on a single agent function (e.g. a marketing agent team). Rejected as the wedge: well-funded point solutions (Ploy, et al.) own single functions; entering there fights on their turf and on thin context. We instead lead with Brain+Ladder and land-and-expand into the Agency — winning on memory + breadth + sovereignty + the ladder, not on any one function.
3. Build the Agency as a direct-to-enterprise SaaS that displaces the agencies. Rejected as mission-violating: per the mission, the agency-in-a-box is the partner agency's force multiplier ("adopted directly, OR delivered through the agencies that already serve them"), not a disintermediation play.
4. Chosen — ship the Agency + the Ladder over the Brain, dogfood-first, agency-channel-aligned. Detailed below.

Decision

Build, as core product surfaces over the existing OKF Company Brain:

1. The Agency — an agentic Digital Experience Agency "in a box." Every org's dashboard gets agentic teams (marketing, engineering, content, delivery) that embody Dossier's own DXA capabilities, grounded in that org's own institutional memory (their OKF/GraphRAG via tenant-scoped MCP), acting on a live shared source of truth, and governed by a human approve/ship loop.
2. The Ladder — an adoption/rollout-plan product. A diagnostic "readout" generated from the org's scraped OKF: a transformation roadmap sequenced by ROI / risk / cultural support (the literal spec for Alex Lieberman's L2 post-diagnostic readout, see provenance).

Sequenced dogfood-first. Phase 0 = run Dossier's own .claude/agents team on Dossier's own OKF, through a daily-standup / approve-ship loop, before any client rollout — the same dogfood-before-rollout discipline as Agentic "sprint board" architecture — a git-resident OKF task board worked by bounded, hook-governed Agent SDK loops.

Proposed architecture mapping (PROPOSED — to be ratified in the topology DEC to follow)

Framed as proposed, to be ratified in the agentic-agency runtime topology DEC (Author the agentic-agency runtime topology DEC + spec (OKF→persona/runbook/team; coordinator/dispatch; per-tenant fleet isolation; Atrium+board+reconcile+MCP composition)):

OKF concept	Agentic-agency role
role	subagent persona
process / workflow	agent runbook / skill
capability	a team
GraphRAG (via MCP)	shared context
board (Agentic "sprint board" architecture — a git-resident OKF task board worked by bounded, hook-governed Agent SDK loops)	dispatch / work ledger
Atrium	live co-working room
reconcile() (The compounding merge — the per-tenant learning loop accumulates by id + confidence instead of overwriting (okf reconcile() + opt-in reconcile in extraction/runtime))	the compounding return + curation guard

A coordinator agent (the Factory pattern) decomposes goals and dispatches to role-bounded teams; each agent is briefed from the org's own memory and writes back into it. Governance = the approve / ship / watch loop; autonomy is a per-team / per-action dial sliding from deterministic (Alex L11) toward self-guided (Alex L14).

Ratification status (2026-06-20): this mapping was ratified by Agentic-agency runtime topology — compile personas from the OKF graph and activate the reserved BoardWorker over the deterministic spine (which corrected the bindings against the real OKF edge vocabulary — e.g. policy/system are ADVISORY/INFORMATIONAL, and there is NO owns edge) and is now verified for the Agency runtime core via that DEC's live run. The Atrium row remains proposed (unbuilt).

Rationale

• The moat = act-and-LEARN vs act-and-forget. Competitors build single-function agent teams on thin context that forget. Dossier's agents act on the org's whole owned memory, and every action compounds back via reconcile() (The compounding merge — the per-tenant learning loop accumulates by id + confidence instead of overwriting (okf reconcile() + opt-in reconcile in extraction/runtime)) into git-owned, portable memory. The loop closing is the defensibility.
• The wedge = land-and-expand. Lead with the Brain + Ladder, expand into the Agency. Do not come to market trying to out-compete well-funded point solutions on any single function; win on memory + breadth + sovereignty + the ladder.
• Channel guardrail (mission-aligned). The agency-in-a-box is the partner agency's force multiplier — "adopted directly, OR delivered through the agencies that already serve them" (Dossier — Mission & North Star, reinforced by Market to every organization; agencies are the highest-leverage channel, not a gate) — not disintermediation. The agency channel is also the test environment for the human-enablement rungs (Alex L5–L8) that Dossier structurally skips.
• We are ~80% scaffolded (DXA vertical = team templates; the 14-subagent self-operating model = the dogfood; board + reconcile + MCP + Agent SDK + planned Atrium = the plumbing) — so this is assembly of owned pieces, not a from-scratch build.

Where Dossier itself sits on the adoption ladder (a finding, recorded): Dossier is born at the top — it lives at L3–L4 (Company Brain + coding agents) and operates at L10–L14 (the production cycle), while skipping L5–L8 (the human-enablement middle) because it is agent-native from birth with no non-technical org. The pitch follows directly: "we'll take you to where we already are." Caveat: dogfooding alone never battle-tests L5–L8 — the agency channel is the fix (it is where the human-enablement rungs get exercised against real non-technical orgs).

Inspiration provenance

Recorded from the real post text the user supplied this session (no paywall caveat needed). These are inspiration / market signal, captured for provenance — they inform, they do not author, the decision:

• Alex Lieberman (@businessbarista) — a 14-level AI-rollout progression observed over 14 months advising execs: L1 company-wide AI audit (map key processes, interview SLT/ELT, survey staff) → L2 post-diagnostic readout (transformation timeline by initiative, prioritized by ROI / risk / cultural support) → L3 "data ducks not in a row" → the "Company Brain" panacea → L4 coding agents for eng/product → L5 enterprise LLM for non-technical champions → L6 expand to all staff → L7 ELT/champion workshops → L8 company-wide training → L9 AI hackathon → L10 leadership prioritizes prototypes→production → L11 first build = back-office quick win, attributable hard ROI, low cultural pushback → L12 token/cost optimization as AI budget balloons → L13 the repeating cycle (problem ID → process map → prototype → test/harden/secure/measure → scale) → L14 deterministic workflow → self-guided agent. Levels can be non-sequential. (This ladder is the literal spec for Dossier's L2 readout product; note L3 independently names "Company Brain.")
• Bryant Chou / Ploy (ex-Webflow founding CTO; launched 2026-06-17, $27M seed, YC + First Round): "turns your website into your hardest working employee"; runs the whole growth system (site, brand, CMS, CRM, campaigns, analytics, SEO, AEO, customer data) vs point solutions; daily-report UX — "what it did, and what it wants to do next. Approve it. Ship it. Or be lazy and just watch it cook." → the agentic-marketing-team pattern + the approve/ship governance UX.
• Factory (AutoWiki): "docs that update on every push," part of building "your own Software Factory, a 24/7 system that continuously produces software with humans as the governance layer." → the 24/7-with-human-governance pattern; AutoWiki = a compounding code→docs loop that Dossier generalizes to all-work→institutional-memory.
• Google Developers (ARD) — Agentic Resource Discovery, an open spec (with Cisco, Databricks, GitHub, GoDaddy, Hugging Face, Microsoft, NVIDIA, Salesforce, ServiceNow, Snowflake) for any agent to securely discover + verify capabilities (tools, skills, MCP servers, other agents) across the web. → the ecosystem / discovery layer; ties to Dossier's tenant-scoped MCP (MCP agentic foundation — tenant-scoped GraphRAG over the OKF KB) and the mission's Nadella north star ("a frontier without an ecosystem is not stable") — each sovereign Dossier tenant should be ARD-discoverable.

Consequences

• Two follow-on DECs are expected and are filed as backlog tasks (below): (a) the "Atrium" live-layer-over-git collaboration surface (still proposed); (b) the agentic-agency runtime topology / architecture spec that ratifies the proposed OKF→persona/runbook/team mapping above — now ratified & verified-scoped as Agentic-agency runtime topology — compile personas from the OKF graph and activate the reserved BoardWorker over the deterministic spine.
• The DXA vertical (Digital Experience Agency vertical as the first reference implementation) is promoted from "reference implementation / economic engine" to the literal team-template source for the Agency — its role/process/workflow/capability atoms become agent personas / runbooks / teams.
• The agentic board (Agentic "sprint board" architecture — a git-resident OKF task board worked by bounded, hook-governed Agent SDK loops) and reconcile() (The compounding merge — the per-tenant learning loop accumulates by id + confidence instead of overwriting (okf reconcile() + opt-in reconcile in extraction/runtime)) gain a second, larger consumer: the Agency dispatches work onto the board and compounds its output back through reconcile — the same primitives, a bigger load.
• The KNOWLEDGE-BRIEF.md seed is promoted toward a shippable L2 readout product (a sibling of the generate-landing skill).
• This does not reverse Market to every organization; agencies are the highest-leverage channel, not a gate: direct adoption AND the agency channel both stand; the Agency is delivered through both doors, with the agency channel as a force multiplier (and the L5–L8 test bed).
• Four follow-up work items filed on the board: Author the agentic-agency runtime topology DEC + spec (OKF→persona/runbook/team; coordinator/dispatch; per-tenant fleet isolation; Atrium+board+reconcile+MCP composition), Author the "Atrium" DEC — the live-layer-over-git co-working room (Yjs + self-hosted Y-Sweet; snapshot bridge → reconcile), Spec the v0 agency dashboard surface (Phase 0 dogfood — Dossier's own .claude/agents team on Dossier's own OKF; daily-standup / approve-ship loop), Build the L2 "adoption readout" generator skill (sibling of generate-landing — MCP-retrieval harness + KNOWLEDGE-BRIEF; a 4-axis scorer over process/workflow atoms → sequenced roadmap → OKF artifact in the client repo).

Review

The gate that would promote asserted → verified: Phase 0 dogfood lands — Dossier's own .claude/agents team runs against Dossier's own OKF through a daily-standup / approve-ship loop on the live board, with at least one real unit of work dispatched, executed, human-approved, and compounded back via reconcile() into git history — demonstrating the act-and-LEARN loop end-to-end on ourselves before any client rollout. The two follow-on DECs (Atrium; runtime topology) ratify the architecture specifics this record leaves proposed.

Promotion (2026-06-20) — SCOPED verified inherited from DEC-0053

The runtime-topology follow-on Agentic-agency runtime topology — compile personas from the OKF graph and activate the reserved BoardWorker over the deterministic spine built and proved the Agency loop LIVE on Dossier's own spine: a bounded multi-turn session dispatched as a persona compiled from real OKF edges → emitted a real atom → capped at inferred → reconcile() (added) → task to review, under per-tenant drain serialization + a budget envelope, ≈$0.016 real spend. That meets the machine-provable portion of this DEC's own gate ("one real unit of work dispatched, executed, human-approved, compounded back via reconcile() into git"). The principal-architect (gate owner) ratified the scoped promotion in DEC-0053 and propagates it here.

Scope of this verified (held tight on purpose):

• Promoted (verified): the Agency-face act-and-learn runtime core — dispatch → persona-from-graph → bounded session → emit → cap → reconcile() → review, with the seven invariants enforced.
• NOT promoted — still asserted / forward work: (a) the human-approve / merge → done → git hop is an inherent human act (DEC-0053 Inv 3) no run can close — verified means proven up to the human gate, which is where the loop is meant to stop; (b) the Ladder face — the L2 readout product is seed-only (KNOWLEDGE-BRIEF.md), unbuilt; (c) the Atrium live-layer and the agentic-dashboard surface — unbuilt; (d) the market / moat / channel thesis — an inherently forward bet, validated only by adoption over time, never by one run; (e) scale (intra-tenant parallelism, per-team budget) and the @anthropic-ai/claude-agent-sdk transport — carried forward per DEC-0053.

Why scoped, not whole: flipping a north-star market-thesis ADR to a blanket verified off one live haiku run would be precisely the overclaim the discipline forbids — you cannot "verify" a multi-year product bet, an unbuilt Ladder/Atrium, or a GTM channel with a single dispatched task. But staying fully asserted would now understate the one thing that IS field-proven: the Agency's act-and-learn loop runs. The scoped verified is the honest middle — the confidence field plus this subsection and the description name exactly what is proven and what is not. Reversibility: two-way door (a confidence re-grade backed by reproduced evidence, tracking DEC-0053; it drops back by the same discipline if the core loop regresses, and widens only as the carried-forward faces are themselves built and proven).