Chris Cordaro

Hybrid retrieval was the lever. Dense-only and sparse-only indexes both lose precision on federal solicitation language, so Prism runs Postgres full-text search and pgvector cosine similarity in parallel, fuses the result sets, and reranks before the LLM ever sees context. I put an intent classifier upstream to decide whether a turn needs retrieval at all; most conversational follow-ups do not, which keeps cheap turns cheap and fast. Answers stream token-by-token with their retrieved sources surfaced alongside, so you can check a claim against its source while the answer is still assembling, not 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

Pulse splits a competitive-intelligence question 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 what comes back against the question; a synthesis agent writes the long-form report; and a review agent runs the consistency and citation pass before anything ships. Every phase emits SSE progress events you watch live, so a long-running report never feels like a black box. I gave each role only the tools it needs (research gets the data APIs, analysis gets structured extraction), which keeps every agent small and its 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

I modeled this as an organization, not a swarm: a four-member command tier sets direction and resolves contention, and a ten-member build crew executes against the tickets command issues. Each persona carries its own system prompt, tool set, and persistent memory file, so an agent that worked an earlier ticket can be re-summoned and pick up where it left off. Coordination is the part most multi-agent systems get wrong. Shared memory here uses content-addressed writes, so two agents working in parallel cannot 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 was packaging. Each product compiles from one source into three shapes: an LLM skill bundle (Markdown plus frontmatter, no runtime), an MCP server (tool definitions plus transport), and a plugin for the three host CLIs. The packaging contract is the load-bearing piece: a single manifest describes capabilities once, and a build step emits the platform-specific artifacts. Zero runtime dependencies means installing is a file copy, not a package-manager dance, and that matters because the 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