Skip to content

OVERVIEW.md

Latest commit

 

History

History
111 lines (68 loc) · 6.99 KB

OVERVIEW.md

File metadata and controls

111 lines (68 loc) · 6.99 KB

Architect Squad — How It Works

What It Is

The Architect Squad is a pipeline of six AI agents that process raw input (meeting transcripts, design documents, voice memos) into structured architecture artifacts. Each agent has a distinct role, reads the previous agent's output, and produces a specific deliverable. The pipeline turns unstructured conversation into a whitepaper with a delivery plan.

The Goal

Take any architecture discussion — however messy, informal, or scattered — and produce:

  1. A structured concept tree of what was discussed
  2. A rationalized architecture that merges new ideas with existing knowledge
  3. An adversarial review that finds gaps and risks
  4. A readable whitepaper suitable for technical leadership
  5. A phased delivery plan with effort estimates and dependencies

The squad does in minutes what would take a human architect days: listen to a 90-minute meeting, extract every architectural concept, challenge them, write them up, and plan the build.

The Pipeline

Raw Input → ROSALIND → HAWKING → OPPENHEIMER ↔ FEYNMAN → TURING → VON BRAUN
              │            │           │            │          │          │
         Normalized    Concept     Rationalized  Challenge  Whitepaper  Delivery
          Input         Tree      Architecture   Report                 Plan

Stage 1: Rosalind — The Normalizer

Named for: Rosalind Franklin, who produced the X-ray crystallography data that revealed DNA's structure.

What she does: Takes raw input (VTT transcripts, meeting notes, documents) and normalizes it into a clean, speaker-attributed, chunked format. Strips conversational noise. Identifies topic boundaries. Produces the shared ground truth that all other agents work from.

Output: Normalized input with speaker attribution, timestamps, and topic segmentation.

Stage 2: Hawking — The Concept Cartographer

Named for: Stephen Hawking, who mapped the invisible structure of the universe.

What he does: Reads the normalized input and extracts a hierarchical concept tree. Each concept gets a type (component, decision, constraint, risk, pattern, etc.), a lifecycle stage (introduced, refined, stable, questioned, obsolete), and evidence links back to the source. Parent-child hierarchy captures how concepts nest. Typed relationships (depends_on, enables, constrains, contradicts) capture cross-cutting connections.

Output: Concept tree with ~30-50 concepts, typed relationships, and evidence refs. This is the architectural skeleton.

Stage 3: Oppenheimer — The Integrator

Named for: J. Robert Oppenheimer, who brought together physicists, engineers, and mathematicians into a coherent effort.

What he does: Takes Hawking's concept tree and rationalizes it against existing architecture knowledge. Merges new concepts with existing ones, resolves conflicts, documents deltas. He produces one unified architecture view — not two overlapping ones. When the merge is ambiguous, he goes back to the transcript to understand intent.

Output: Rationalized architecture with clear layers, grouped domains, decisions with rationale, and conflict resolutions.

Stage 4: Feynman — The Challenger

Named for: Richard Feynman, who dismantled the Challenger disaster's root cause with a glass of ice water and an O-ring.

What he does: Stress-tests Oppenheimer's rationalized architecture. Finds unexamined assumptions, internal contradictions, missing concepts, over/under-specification, feasibility concerns, and security gaps. Each challenge gets a severity rating (critical/high/medium/low). His output is a forcing function — Oppenheimer must resolve critical challenges before the architecture proceeds.

Output: Challenge report with verdict (APPROVE / REVISE / REJECT) and categorized findings.

Stage 5: Turing — The Whitepaper Author

Named for: Alan Turing, who formalized computation itself.

What he does: Synthesizes Oppenheimer's architecture and Feynman's challenges into a readable, comprehensive whitepaper. Structured for a technical audience: context, problem, solution, components, decisions (as ADRs), risks (incorporating Feynman's valid challenges), and roadmap. Uses text-based diagrams where helpful.

Output: Architecture whitepaper (typically 30-45 KB, 15+ sections).

Stage 6: Von Braun — The Delivery Planner

Named for: Wernher von Braun, who turned theoretical rocketry into actual moon landings.

What he does: Takes Turing's whitepaper and Feynman's challenges, and produces a phased delivery plan. Sequences work by dependency and risk. Critical-path items and Feynman's critical challenges go in the earliest phases. Each work item gets T-shirt sizing, prerequisites, and success criteria.

Output: Phased delivery plan with effort estimates, dependencies, blockers, and gates.

Scribe (Observer — not yet implemented)

Named for: The unnamed scribes who preserved knowledge across civilizations.

What it does: Observes all pipeline stages and maintains a decision log — an append-only record of every architectural decision, who made it, when, and why. Acts as institutional memory across multiple pipeline runs.

First Pipeline Run — Results

Input: 148 KB VTT transcript — Shane Solomon and Casey Irvine discussing a shared knowledge graph for AI agent memory systems (March 8, 2026).

Stage Agent Output Size
1 Rosalind Normalized input 8.4 KB
2 Hawking 47 concepts, 24 relationships 29.8 KB
3 Oppenheimer 4-layer rationalized architecture 11.8 KB
4 Feynman Verdict: REVISE (operationally immature) 25.8 KB
5 Turing 15-section whitepaper 42.8 KB
6 Von Braun 18-week delivery plan to v1.0 36.2 KB

Total: 154.8 KB of structured artifacts from a 148 KB transcript.

Location: agents/architect-squad/outputs/2026-03-08-shared-knowledge-graph/

Current Status

  • Schemas: Defined in agents/architect-squad/schemas/ (concept-tree, rationalized-architecture, challenge-report, whitepaper, delivery-plan, decision-log, pipeline-manifest)
  • Agent prompts: Defined in agents/architect-squad/agents/ (all six agents + scribe)
  • Pipeline execution: Manual — sequential executePrompt calls through the brain. Each stage takes 2-5 minutes.
  • Concept tree integration: The web UI's architecture discussion mode uses Hawking's concept-tree schema natively — concepts built in the UI are compatible with the squad pipeline.

What's Next

  1. Automate the pipeline — single command or skill that runs all six stages sequentially
  2. Oppenheimer ↔ Feynman loop — if Feynman's verdict is REVISE, send challenges back to Oppenheimer for resolution, then re-challenge
  3. Scribe implementation — decision log that persists across runs
  4. Web UI integration — feed concept trees from architecture discussion sessions directly into the pipeline
  5. Multi-input merging — run the pipeline on multiple transcripts and merge the concept trees