Agent Fabric
A provider-neutral coordination layer that keeps multi-agent tasks, messages, decisions, and RPIV gates consistent across interchangeable tools.
- Audience
- Software teams and AI-assisted developers
- Role
- Methodology creator, architect, and builder
Parallel coding agents produced activity without durable continuity.
Agents could generate code quickly, but research, plans, decisions, and validation often disappeared between sessions. Multiple agents needed a shared operating method and a way to preserve what had already been learned.
One coordination contract made agent work portable and governable.
I created the Research, Plan, Implement, and Validate method and embedded it in a TypeScript coordination layer for agents, people, tasks, messages, and durable artifacts. The system progressed from a local terminal workflow to a central service with stable APIs, real-time events, interchangeable adapters, and a shared dashboard. Investigation remained separate from action, decisions and outcomes persisted, and validation became a required part of the work.
What this case can and cannot prove.
Public evidence is classified so a private implementation, deployed system, measured result, and advisory artifact are never presented as equivalents.
- Context
- Parallel coding agents produced activity without durable continuity. Each agent needed custom knowledge of the task, messaging, and persistence tools behind the work, and no single record held authoritative state.
- Clifford's role
- Methodology creator, architect, and builder. Clifford created the Research, Plan, Implement, and Validate method and built the coordination layer that carries it.
- Evidence
- Implemented private system, alongside a sanitized coordination architecture snapshot captured August 13, 2026. The snapshot shows the coordination contract, the gates, required artifacts, ownership and approvals, and interchangeable task, messaging, and persistence adapters, without exposing source code, tasks, messages, or credentials.
- What changed
- Research, plans, decisions, verification results, ownership, and approval state became durable artifacts that outlast a session. A handoff carries the current gate, required artifacts, decisions, approval, ownership, and blockers, so the next agent or person resumes the work rather than rebuilding it from a transcript. Agent Fabric remains the coordination contract while Flowplane remains the operating environment.
- Not claimed
- Public adoption, productivity gains, financial impact, and public source availability are not claimed.
- Implemented private system
- A working TypeScript coordination system confirms the shared agent contract, RPIV workflow, artifact model, handoff protocol, adapters, APIs, real-time events, and operating dashboard.
- Public artifact
- Sanitized coordination architecture snapshot captured August 13, 2026. Documents system relationships without exposing source code, private tasks, messages, repository details, or credentials.
The contract separates operating method from tooling.
This sanitized view records the implemented coordination model without exposing source code, private work data, or credentials.
Captured August 13, 2026
Coding agents · Engineers · Reviewers
Register · claim · communicate · hand off · resume
- RPIV gates
Work advances through an explicit operating method.
- Required artifacts
Research, plans, decisions, handoffs, and verification persist.
- Ownership and approvals
Responsibility, blockers, and review state move with the work.
- Task adapter
- Messaging adapter
- Persistence adapter
The coordination layer preserved decisions between sessions.
These outcomes describe what the implementation made possible. They are not generic product promises.
Established a repeatable operating method for multi-agent software work.
Preserved research, decisions, plans, and results across coding sessions.
Improved continuity between parallel agents and later work.
One contract carried the method across interchangeable tools.
The system was organized around an operating sequence people could understand, govern, and improve.
Research
Understand the system and preserve relevant evidence.
Plan
Turn findings into an explicit sequence of accountable work.
Implement
Execute the approved plan in a controlled environment.
Validate
Test the result and retain what the system learned.
The decisions, reversals, and evidence behind the result.
Each movement records how the work changed as evidence replaced the starting assumptions.
Outcome
The intended outcome was one coordination layer through which multiple coding agents could share tasks, communicate, preserve decisions, and follow RPIV gates without depending on a particular model, agent provider, task tracker, messaging system, or persistence backend. Flowplane served as the integrated operating environment, while Agent Fabric provided an interchangeable coordination layer beneath multi-agent work. This boundary kept the operating method, task state, messages, decisions, and handoffs consistent even as the tools behind them changed.
Diagnose
The presenting problem appeared to be communication between coding agents. The deeper problem was coupling. Each agent needed custom knowledge of the task, messaging, and persistence tools behind the workflow, while direct exchanges did not guarantee a shared authoritative state. Changing one backend could disrupt the workflow, and agents could disagree about task ownership, decision history, or handoff status because communication and operating state were spread across separate tools.
Design
One option was to build direct point-to-point integrations between every agent and each task, messaging, and persistence tool. That approach was rejected because it would create an expanding integration matrix in which every backend change required agent-specific changes and RPIV gates could be applied inconsistently. It also left context windows to be managed manually. Evidence, decisions, instructions, and prior work had to be repeated for every task, consuming context without establishing one durable operating record.
Decide
The first implementation centered on a local terminal workflow. That approach proved the coordination method, but it also showed the limits of keeping agent state and operating visibility inside one local session. The architecture progressed toward a central service with stable APIs, real-time events, and a shared dashboard. The reversal retained the RPIV method and abstraction boundary while changing how the coordination layer was accessed and observed.
Execute
Agent Fabric deliberately did not choose the model, write the code, replace the task tracker or messaging backend, or dictate the user interface. The system standardized the coordination contract and adapted existing tools behind it. Agents could register, exchange messages, manage work state, and follow RPIV gates through one interface without knowing which backend implemented each responsibility. Keeping execution and product interfaces outside the fabric preserved interchangeability.
Transfer
Agent Fabric converted transient agent context into durable shared artifacts. Research, plans, decisions, verification results, messages, approvals, task ownership, and handoff state could move between sessions, agents, and people through the same coordination contract. The resume protocol gave the next contributor the evidence and operating state needed to continue, including what had been decided, what was approved, who owned the work, and what remained blocked.
Measure
The unexpected result of reviewing handoff completeness was that successful message delivery did not make work reliably resumable. A handoff only supported the next agent or person when it also included the current gate, required artifacts, decisions, verification state, approval, ownership, blockers, and the next action. That finding expanded the system to include required artifact templates, a separate decision log, handoff packets, a resume protocol, gate review, and dashboard visibility into missing or blocked work.
I created the methodology and the system that operationalized it.
Agent Fabric connected my work in architecture, coding harnesses, recursive intelligence, and decision continuity. RPIV later informed other development and go-to-market systems.
Working through a similar decision?
Bring the desired outcome, the systems already in place, and the constraint keeping the work from moving. The first conversation will test whether the problem is architecture, ownership, data, capability, or execution.