Skip to content

You finished the course. Now what?#

You built the primitives behind every agent framework. You understand what an LLM call is at the byte level, how ReAct loops and terminate, how memory composes, how cost routes, how safety intercepts, how daemons recover. The rest is reps.

This guide is the "what's next" — four paths, pick one.

1. Ship a portfolio project this weekend#

The projects/ directory ships six end-to-end agent MVPs. Each one is a real business problem, fully runnable in mock mode, ~200-600 lines of real code (not stubs). Pick one. Spend 8-20 hours extending it. Put it in your GitHub. Link it on your resume.

  • projects/customer_support_agent/ — multi-turn agent with tool use and human-in-the-loop escalation. Wire it to your company's knowledge base and you have a working support bot.
  • projects/code_review_bot/ — PR triage agent. Reads a diff, runs static checks via tools, produces a structured review with risk flags.
  • projects/data_analyst_agent/ — natural-language-to-SQL-to-chart. Ask "top customers by spend last quarter"; get a chart + summary.
  • projects/research_assistant/ — document research with page-level citations. Drops straight into internal docs search.
  • projects/knowledge_base_rag/ — hybrid keyword + semantic search over Markdown docs. Answer grounding checker verifies every claim maps to a real source.
  • projects/multi_agent_debate/ — decision support via N debater agents + moderator. "Should we migrate from Postgres to DynamoDB?"

Each project has a README.md with architecture, cost estimates, and failure modes. Read that, then run SWARM_MOCK=true python -m projects.<name>.agent "your question" and watch it work.

2. Read these codebases next#

Now that you know what the abstractions hide, go read the mainstream frameworks. You will understand them in hours instead of weeks.

LangGraph — github.com/langchain-ai/langgraph Open libs/langgraph/langgraph/graph/state.py. This is a state-machine runtime for agent graphs. Your Chapter 3 LoopState is the same idea, simpler. Compare the two; decide when you want the graph abstraction (multi-branch workflows) vs. the bare loop.

CrewAI — github.com/crewAIInc/crewAI Open src/crewai/crew.py. Their "crew" is your Chapter 6 orchestrator-workers pattern. Pay attention to how they handle worker failures and task dependencies; that is the DAG orchestration you will probably build yourself eventually.

Claude Code — github.com/anthropics/claude-code (open-sourced April 2026) This is the production reference. Every pattern in this book was cross-checked against it. Start with the main agent loop; then the tool dispatch; then the memory compaction pipeline. Compare section by section with your notes. The deltas are where production is harder than pedagogy.

Anthropic Agents SDK — github.com/anthropics/anthropic-sdk-python Read their Message.stream() and tools types. This is what streaming from Chapter 2 looks like when a big team polishes it for a year.

OpenAI Agents SDK — github.com/openai/openai-agents-python Compare their Agent class to your call_agent. The Responses API (their stateful primitive) is a different design choice worth understanding.

3. Read these papers in this order#

The bibliography has everything; this is the reading order that matches the book.

  1. ReAct (Yao et al. 2022) — arxiv.org/abs/2210.03629 The foundation. Your Chapter 3a loop is this paper in code. Read it once so you know what you built.
  2. Self-Refine (Madaan et al. 2023) — arxiv.org/abs/2303.17651 The generator/critic pair from Chapter 4. The paper framed it; you implemented it.
  3. MemGPT (Packer et al. 2023) — arxiv.org/abs/2310.08560 The 3-layer memory system from Chapter 4 was inspired by this. Their paging analogy (OS pages ↔ memory tiers) is the clearest explanation.
  4. Mixture of Agents (Wang et al. 2024) — arxiv.org/abs/2406.04692 Chapter 6's parallel-aggregate pattern. MoA is what happens when you take fork-join and add a clever aggregator.
  5. Voyager (Wang et al. 2023) — arxiv.org/abs/2305.16291 The skill library from Chapter 8. Read this for the self-directed exploration + distillation insights.
  6. Constitutional AI (Bai et al. 2022) — arxiv.org/abs/2212.08073 Chapter 7's safety layer is inspired by this training technique. You implemented the inference-time version.
  7. Reflexion (Shinn et al. 2023) — arxiv.org/abs/2303.11366 Generalizes the critic pattern with verbal reinforcement learning. If you liked Self-Refine, this is the next step.
  8. Lost in the Middle (Liu et al. 2023) — arxiv.org/abs/2307.03172 Explains why Chapter 7's compaction matters. The paper is short and worth reading in full.
  9. DSPy (Khattab et al. 2023) — arxiv.org/abs/2310.03714 Read when you want automatic prompt optimization. See the PromptTuner in swarm/optimize/ for a hand-rolled version.

After these, follow citations. The field moves fast; the fundamentals do not.

4. Join the conversation#

  • GitHub Discussions on this repo — open a thread about what you built, what broke, what you want to see next. Tag @TheAiSingularity.
  • r/LocalLLaMA — practitioners arguing about models, tools, prompts. Cut the noise, keep the arguments.
  • r/AIEngineer — more production-focused.
  • Anthropic Discord — Claude Code users; fastest channel to learn about plugin conventions and new MCP servers.
  • Hugging Face forums — for model-level conversations.

Leaderboards to watch: - SWE-bench — how well do agents fix real GitHub issues - GAIA — multi-step reasoning under tool use - HELM — the most rigorous model-evaluation effort

5. Build something that matters#

The course gave you the primitives. Frameworks will come and go. Models will get better and cheaper. The shapes you learned — agent loop, tool contract, eval harness, hook bus, cost router, memory consolidation, skill library, plugin format — those will be in every serious system for the next decade.

Pick a real problem in your work. Build the simplest agent that moves the needle. Ship it. Measure it. Improve it.

If you build something with this course, open an issue and tell us. We will link the best ones from the README.

Good luck.