Agent Pipeline Architect

The Five Roles

• UI layer — where the human types. In the tweet's build it's Streamlit: a pure-Python web front end.
• Router — a cheap, fast LLM call that classifies the request and decides which specialist handles it. Routing keeps expensive agents from running on every message.
• Research agent — gathers facts first: LLM options, frameworks, deployment strategy — and stores them instead of holding them in one prompt.
• Shared memory store — a database / vector store both agents read and write. This is the shared-state pattern: agents communicate through durable state, not giant prompts.
• Coding agent — reads stored research before generating code, so its stack choices are grounded, not hallucinated.

Why Shared State Beats One Giant Prompt

Stuffing research + instructions + history into a single prompt hits context limits and degrades attention ("lost in the middle"). The shared-state pattern fixes this:

• Write once, read many — research is done once, then every downstream agent queries it.
• Auditability — you can inspect exactly what the coder read before it generated code.
• Failure isolation — if the coder crashes, research survives; rerun only the failed hop.
• Cost — the router can be a small model; only specialists use the big one.

Try it: switch the memory store OFF above and watch the coding agent go in blind — quality drops because nothing carries between hops.

Build Walkthrough (7 Steps)

1. Define the task boundary: what the assistant will and won't do.
2. Pick models: a small router model + a strong generation model.
3. Stand up the memory store (SQLite, Postgres, or a vector DB like Chroma).
4. Write the research agent: search → summarize → store(key, findings).
5. Write the coding agent: read(keys) → plan → generate → store output.
6. Wire the router: classify intent → dispatch to the right agent.
7. Build the UI in Streamlit (real minimal version):

import streamlit as st

st.title("Multi-Agent Assistant")
task = st.text_input("What should I build?")
if st.button("Run") and task:
    route = router(task)          # cheap LLM classify
    notes = research(task)        # agent 1
    store.write("notes", notes)   # shared state
    code = coder(store.read("notes"), task)
    st.code(code, language="python")