Recap and final exam
Ten modules to move from a single agent to a documentation crew that a team can review a week later. Here is the course condensed, then the threads that run through it, then the exam.
The course at a glance
| Module | The essential point |
|---|---|
| 1. When several agents beat one | Split when steps have distinct criteria, distinct tools and a checkpoint; otherwise a single agent or a script wins |
| 2. Agents, roles and goals | Four fields matter: role, goal (single sentence), backstory (two-three sentences), model per agent |
| 3. Tasks, dependencies, outputs | description, agent, expected_output; use context=[…] and prefer output_pydantic for machine consumers |
| 4. Sequential vs hierarchical | Sequential when the pipeline is enumerable, hierarchical when the order depends on runtime — the second costs 2 to 3 times more |
| 5. Shared tools | Built-ins first; agent-level for identity, task-level for step; the Writer gets no tools by design |
| 6. Delegation and supervision | Exactly one delegating agent (the Manager); briefs are assignments, not requests; cap max_iter and max_rpm |
| 7. Shared memory and context | Short-term for side facts, entity for names and versions, long-term rarely; cap retrieval k and prefer context=[…] for primary input |
| 8. Cost, latency, limits | ~$0.04 and 45 s on the running project; measure with usage_metrics, temperature 0 on structured outputs, pin model versions |
| 9. Debugging a stuck crew | Three patterns — delegation loop, vague expected_output, tool blob — each with a precise fix; verbose=True from day one |
| 10. Documentation crew | Crew beats single agent on coverage and fabrication; ship behind a human veto, pin versions, grow the style guide file |
The threads running through the course
A crew is a set of trade-offs, not an upgrade. Modules 1 and 8 named the same reality from two angles: splitting one agent into four multiplies the bill, doubles the latency, and compounds accuracy downwards — in exchange for cross-checks that only a separate agent can perform honestly. Modules 5 and 6 (tools and delegation) exist to preserve that separation; the moment the Writer gains a review tool or a peer delegation right, the crew collapses back to a single agent with more steps.
Vagueness is the single most expensive bug. Modules 3 and 9 come back to this from opposite ends. A vague expected_output in module 3 lets the model iterate on a moving target; a vague delegation brief in module 6 triggers the loops of module 9. The fix in every case is a checklist: what the shape of the result is, which fields are required, which are forbidden. Every hour spent writing a testable expected output saves a day of debugging.
Determinism where you can, stochasticity where you must. Module 4 chose the sequential process because the documentation pipeline is enumerable. Module 8 imposed temperature 0 on every structured-output agent and pinned model versions. Module 10 pinned the prompt text in git. The Writer keeps a small temperature because prose written at zero reads badly — that is the one place stochasticity is worth its cost, and it is confined to a single agent whose output is not consumed by another agent.
Every deployed crew keeps a human veto. Module 10 said it explicitly and every earlier module worked to make it cheap. The Reviewer catches most fabrications; the Manager arbitrates; the style guide file grows over time. None of that replaces the last human review before publication. The productive framing is that the crew delivers a first draft already sanity-checked by a second pair of model eyes, and the human is the third pair — non-negotiable.
The final exam
The exam has 40 questions covering the ten modules: when a crew helps and when it does not, defining agents and tasks, choosing sequential or hierarchical, attaching tools and setting permissions, safe delegation, using memory without context bloat, budgeting a run, and diagnosing a stuck crew from its trace.
Several questions present concrete situations to diagnose: a crew that runs for twelve minutes and produces nothing, a Reviewer that approves every draft, a Writer that fabricates a feature the brief never mentioned, a bill that tripled overnight. It is judgment that is assessed, not the recitation of function signatures.
On success, your certificate of completion is issued immediately; its number is verifiable by any third party on the platform.
Take the table above and, for each row, ask yourself "how would I see that I am wrong here?". If you can name the three signals that justify splitting into a crew, the three thresholds that gate shipping, and the three debugging patterns of module 9, you are ready. Good luck!
Final exam
Ready to validate this course?
40 questions drawn at random from the course bank · passing score 70% · verifiable PDF certificate issued immediately on success.
Start the examYou need to be signed in to your InSkillML account with an active subscription. You can also start the exam from My courses.