Fast Path And Reading List
The compressed path: build enough taste quickly that you can make good system choices this week.
- Four passes: 90 minutes → one day → three days → one week.
- Do not add more than one serious abstraction in the same week.
- Best first project: the tool fitness bench — better tools improve every agent.
- Speed comes from removing choices until the system proves it needs them.
The Fast Path
If you need to move fast do this in passes.
Pass 1: 90-Minute Orientation
Write one page:
What is this trying to orchestrate?
Where should control live?
What tools/context are needed?
What state must survive?
What needs evals or human approval?
That is enough to stop flailing.
Pass 2: One-Day Build
Pick one real task and build the smallest useful version.
Use this shape:
intake
-> context
-> action
-> verify
-> artifact
Do not start with ten agents. Start with one path that leaves evidence.
Output:
runs/<task>/
input.md
notes.md
tool-outputs/
final.md
eval.md
Pass 3: Three-Day Sprint
Day 1: Build the simple workflow.
- one task
- one model route
- one or two tools
- one artifact contract
- one manual eval
Day 2: Add operational discipline.
- trace what happened
- record tool calls
- record cost/latency if available
- add a failure note
- add one human approval gate if risk exists
Day 3: Decide the next layer.
Use the promotion rule:
Need branches or state? Add graph.
Need retries or delayed work? Add durable runner.
Need better tools? Improve MCP/tool shape.
Need quality proof? Add eval bank.
Need repeatability across clients? Add or refine a shared workflow definition.
Pass 4: One-Week Upgrade
Only after the three-day sprint works choose one upgrade:
- LangGraph-style graph for state and branching
- Temporal/Inngest-style durable execution for retries and waits
- tool fitness bench for your MCP surface
- model routing scorecard for cost and latency
- failure corpus for eval-driven improvement
- run ledger for cross-system learning
Do not add more than one serious abstraction in the same week.
What To Read First
Must Read
Read When You Hit The Problem
What To Skip For Now
Skip anything that does not answer a current design question.
Specifically do not spend the first week on:
- comparing every agent framework
- building a general platform before a real workflow works
- chasing multi-agent swarms before a single-agent baseline exists
- chasing self-improvement loops before an eval bank exists
- adding durable infrastructure before there is a retry problem or a wait problem or a resume problem
- studying protocol theory before there is a tool or context boundary to expose
Speed comes from removing choices until the system proves it needs them.
The First Real Project
Build one of these first:
- Tool Fitness Bench: tests whether a local MCP/tool is agent-friendly.
- Agent Run Ledger: normalizes run metadata and artifacts and evals and failures and cost and latency.
- AI Orchestration Lab: runs the same task through one-shot and workflow and graph and human-in-loop patterns.
- Workflow Promotion Checklist: decides when prose becomes a script or a graph or a durable runner or a service.
Best first pick:
Tool Fitness Bench.
Reason: tools are the leverage point you already have. Better tools improve every agent and every workflow without forcing a runtime decision too early.
What To Remember
Move fast. Do not move blind.
- Start with one real task.
- Keep the first system inspectable.
- Use workflows when steps are known.
- Use agents when decisions are open-ended.
- Use graphs when state, branching, or recovery matters.
- Use durable runners when time and failure matter.
- Use artifacts so humans can inspect the work.
- Use evals before claiming improvement.
- Use protocols at boundaries.
- Keep humans where consequences matter.
The goal is not to finish a curriculum. The goal is to build taste by shipping small and inspectable systems quickly.