Skip to content
One Long Tail
Menu

One track

Become an AI Specialist

Agent systems engineering: not how a model is written, but how the machine around it is built. The loop, the gate that measures it, the surface it reaches through, the graph it runs on, and the line that runs without you. 8 modules, 46 lessons. Every lesson is a hands-on lesson: you drag and tap the mechanism until it runs, and then you break it and watch it fail.

No code anywhere in this track. What you copy out of a lesson is a brief template, a pass rule, a topology diagram and the failure shapes to watch for.

  1. Module 1 · 6 lessons · 6 ready

    The loop

    What a run is, what one turn is, and what ends a run. Builds the ring: four stations, a counter, an exit hatch.

    What it changes: Changes nothing — it builds the base object, the ring. The other seven modules are each one change to this ring.

    1. Name the six jobs the model doesn't doIs it the model that runs the agent?CompletedOpen the lesson →
    2. See how many turns one run really takesOne answer came back — how many steps made it?CompletedOpen the lesson →
    3. Write the stopping rule before the runWho decides the work is finished?CompletedOpen the lesson →
    4. Set the ceiling on what one run may spendHow long should it keep trying, and at what cost?CompletedOpen the lesson →
    5. Tell the spinning run from the quitting oneWhy does it sometimes never stop, and sometimes give up at once?CompletedOpen the lesson →
    6. Let it pick up exactly where it stoppedA long job stops halfway — where does it resume from?CompletedOpen the lesson →

    Open module 1

  2. Module 2 · 8 lessons

    The gate

    The instrument for measuring that something works: when the rule is written, the three ways to measure, the rubric, volume, a held-back test set, outcome and path, the judge's independence, the broken gate.

    What it changes: Fits a gate to the ring. A barrier that drops onto the rail: nothing passes until the measurement comes back clean, and what does not pass falls to the tray.

    1. Write the pass rule before the runDid it work? What am I actually comparing it against?Completed
    2. Pick the right one of the three ways to measureHow many ways are there to check an answer, and which one fits?Completed
    3. Tell the judge exactly how to scoreThe judge gives it a score — based on what?Completed
    4. Measure on twenty cases, not oneIt worked once. Will it keep working?Completed
    5. Prove it works on cases it never sawIt passes my examples — will it pass the next one?Completed
    6. Score the outcome and the path separatelyThe answer is right — does it matter how it got there?Completed
    7. Stop the producer grading its own workIs the thing scoring the work the same thing that did it?Completed
    8. Distrust a check that never fails anythingEverything passes the check. Is that good news?Completed

    Open module 2

  3. Module 3 · 7 lessons

    Surface and context

    What the agent can reach for and what is put in its hands: how many tools, telling them apart, designing the return, the error that teaches, writing your own, inside the compiler, the tray filling up.

    What it changes: Changes the ring's outer surface and its compiler. The wall of outward-facing tools narrows, and what enters the compiler funnel gets checked.

    1. Give it the fewest tools that finish the jobHow many tools should it have — all of them?Completed
    2. Make two similar tools tell themselves apartTwo tools look like they do the same thing — which one gets picked?Completed
    3. Make what the tool returns readableWhat should a tool hand back — everything it found?Completed
    4. Make the error message fix the next attemptThe tool failed — what should it say?Completed
    5. Decide which step deserves to become a toolShould this step become a tool, or stay something I explain?Completed
    6. See exactly what it gets handed each turnOn one turn, what exactly is put in front of the model?Completed
    7. Stop it forgetting your first instruction late in a runLate in a long run, why does it drop what I said at the start?Completed

    Open module 3

  4. Module 4 · 5 lessons

    Protocol and package

    Choosing what gets attached to the surface: the protocol's three roles, what a server offers and cannot see, the context price of adding one, the package that loads on demand, the three-way decision.

    What it changes: Changes what is attached to the surface and the shelf behind it. Module 3 measured what one tool costs; this module spends that measurement on a choice.

    1. Stop wiring every outside tool by handHow does an outside tool get attached to the agent at all?Completed
    2. Know what a server can and cannot seeWhat does a server offer me, and what does it get to see of me?Completed
    3. Measure what a server costs before you add itWhich server should I add, and what does adding it cost me?Completed
    4. Write the procedure once, let it load when neededHow do I stop explaining the same procedure every single time?Completed
    5. Choose tool or package by a written ruleIs this need a tool, a package, or something I build myself?Completed

    Open module 4

  5. Module 5 · 7 lessons

    Graph

    Topologies: a chain and the gate between steps, a router, a parallel split, a parallel vote, manager and worker, a hand-off between peers, evaluator and improver.

    What it changes: Multiplies the ring. The rail forks in two, opens into parallel lanes, and one ring feeds the others.

    1. Split the big job into steps, and check between themI asked for four things at once and got none of them right. Why?Completed
    2. Stop running every request through one pathEvery request is different — why do they all take the same path?Completed
    3. Run the parts that do not wait for each other at onceWhich parts can run at the same time, and which cannot?Completed
    4. Know which answer to trust when they disagreeI ran it twice and got two different answers — which one is right?Completed
    5. Don't give work to the one splitting itWhat happens when the one splitting the work also does the work?Completed
    6. Brief the next run as if it knows nothingWhen I hand the work over, what does the other side not know?Completed
    7. Make the second draft actually betterI asked it to improve the draft — why is it rarely better?Completed

    Open module 5

  6. Module 6 · 4 lessons

    The research run

    Research has its own topology and its own failures: writing the plan outside the context, the four parts of a sub-agent brief, source quality, the citation pass.

    What it changes: Runs the multiplied ring on one real job. For the first time the graph, the gate and the compiler all have to hold at once.

    1. Write the plan outside the contextHalfway through a long research run, why is the plan gone?Completed
    2. Stop parallel searches finding the same thingI ran five searches in parallel and they all came back with the same thing. Why?Completed
    3. Stop it preferring a weak source to an authoritative oneIt treats every source as equal — how does it tell them apart?Completed
    4. Make the citation check its own separate passDoes every sentence in the write-up really come from its source?Completed

    Open module 6

  7. Module 7 · 4 lessons

    The harness

    The six things the machine owns rather than the model: loop control, tool dispatch, context assembly, the permission gate, state, visibility.

    What it changes: Changes no part — it names the body underneath. Every piece drawn across modules 1 to 6 comes together here in a single cross-section.

    1. Who closes the turn, and who actually runs the toolWhen the model calls a tool, who actually runs it?Completed
    2. Who assembles the context, and who grants permissionWho decides what reaches the model, and what it is allowed to do?Completed
    3. Make a finished run something you can still inspectThe run finished and it was wrong — how do I find out what happened inside?Completed
    4. Stop the same run ending differently twiceI ran the same job again and it ended completely differently. Why?Completed

    Open module 7

  8. Module 8 · 5 lessons

    Running it without you

    Setting up a line that runs without you, and running it: the trigger, the blast radius, the irreversible move, the two escalation triggers, the one place you look in the morning, drift, per-run accounting.

    What it changes: Leaves the body on its own. The human steps out of the ring and takes a seat at the tray.

    1. Set the line up once and let it start itselfHow do I stop starting the same job by hand every morning?Completed
    2. Put the irreversible move behind an approvalRunning without me, what is the worst thing it can do?Completed
    3. Write the moment it has to come and get youWhen should a line running without me come and get me?Completed
    4. Have one place to look in the morningTen lines ran overnight — what do I look at in the morning?Completed
    5. Notice the quiet drift, and be able to stop itIt has run for weeks and the output is not what it was — how would I notice?Completed

    Open module 8

6 of 46 lessons are built so far. The rest are written and waiting to be built.