Chris Cordaro

Hybrid retrieval was the lever: a single dense-only or sparse-only index loses precision on federal solicitation language, so the copilot runs Postgres full-text search and pgvector cosine similarity in parallel, fuses the result sets, and reranks before the LLM call. An upstream intent classifier decides whether a turn needs retrieval at all (most conversational follow-ups do not) which keeps latency and cost down on cheap turns. Responses stream token-by-token with the retrieved sources surfaced alongside, so the reader can verify a claim against its source as the answer assembles itself rather than after it finishes.

• → Hybrid full-text + vector retrieval with rerank fusion
• → Intent classifier short-circuits retrieval for conversational follow-ups
• → Sources surfaced inline as the answer streams, not appended at the end

The pipeline splits a competitive-intelligence task into four typed phases that run as a directed graph: research agents fan out across SAM.gov, USASpending, FPDS, and SBA in parallel, analysis agents structure their findings against the question, a synthesis agent produces the long-form output, and a review agent runs the consistency + citation pass before the report ships. Each phase emits SSE progress events the reader watches live, so a long-running report does not feel like a black box. Role specialization lets each agent stay small and focused: research agents have data-API tool access only, analysis has structured-extraction tool access only, and so on, which keeps tool-call overhead and prompt size predictable.

• → Four typed phases as a directed graph: research → analysis → synthesis → review
• → Per-phase tool access, so each agent stays small and focused
• → SSE progress streamed to the reader for visibility into long-running reports

Modeled as an organization, not a swarm: a four-member command tier sets direction and resolves contention, a ten-member build crew executes against tickets the command tier issues. Each persona has its own system prompt, tool set, and persistent memory file, so an agent that worked on an earlier ticket can be re-summoned and pick up where it left off. The coordination layer is the part most multi-agent systems get wrong: shared memory uses content-addressed writes so two agents working in parallel can not silently overwrite each other, and the command tier arbitrates when two build agents claim overlapping work.

• → Four-member command tier, ten-member build crew, fixed responsibilities per role
• → Persistent per-persona memory survives across sessions and re-summons
• → Content-addressed shared memory prevents silent overwrite under parallel execution

The interesting decision here was packaging. Each agent product compiles to three artifact shapes from one source: an LLM skill bundle (Markdown + frontmatter, no runtime), an MCP server (tool definitions + transport), and a plugin for harness CLIs. The packaging contract is the load-bearing piece: a single manifest describes capabilities once, and a build step emits the platform-specific shapes. Zero runtime dependencies means an install is a copy, not a package-manager dance, which matters when the target audience is engineers who want to try a tool in 30 seconds and decide.

• → One source compiles to skill, MCP server, and plugin shapes
• → Zero runtime dependencies; install is a file copy
• → Same agent works identically across Claude Code, Gemini CLI, and ChatGPT CLI