Agentic AI in Practice

From a single request to systems that pursue a goal: instructions, model and effort, skills, agents, goals, sub-agents and workflows, each built on the one before, with real runs and every finding checked.

Agentic AI

1 of 7 parts published

Start with part 1

This series is about using agentic AI to complete a task well without spending more than the task requires. Current AI tools are built around several concepts: instructions, model and effort levels, skills, agents, goals, sub-agents, and workflows. Each can make the work more accurate, faster, or cheaper, and each adds cost and complexity when the task doesn’t call for it. Using agentic AI efficiently means knowing what each concept does, when it pays off, and when something simpler will do.

The parts introduce these concepts one at a time, in the order a task comes to need them. A plain request becomes a complete instruction; the model and its effort level are chosen to suit the task; the instruction becomes a skill that can be reused; an agent takes over the steps; a goal keeps it working until the work is done; sub-agents share the work; and a workflow fixes the structure so that it runs the same way every time. Each part explains the concept, shows how to apply it, and ends with the limitation the next part addresses.

Each part works in the same setting: turning public reports into a LinkedIn post, a newsletter section, and a short-video script, the kind of writing that dominates work-related use of ChatGPT 1. The task starts with one report and grows with the series, to longer reports, several at once, and finally a new one every week, so each concept appears where it is actually needed. Because the setting stays the same, each concept can be judged by what it changes in the result, the time taken, and the cost. The runs are real and dated; each names the model and the effort level it used, and every claim about them is checked against the source. By the end, a reader should be able to look at a task and choose the simplest arrangement that does it well.

The parts, in order

  1. Part 1Instructions

    From Asking to Instructing

    What should a request to a model contain?

    Most work with a language model begins by just asking. A reliable result begins when the request becomes an instruction that states its context, its constraints, and what done looks like.

    PublishedOctober 12, 202610 minute readRead part 1

    Where it stopsOne model at one effort level: would another do better, faster or cheaper?

  2. Part 2Model and effort

    Model and Effort: Choosing the Model and the Effort Level for the Task

    Which model, and how much reasoning, does each task need?

    Part 1’s instruction, run on several models and at each effort level and scored with the same checks: what each choice changes in accuracy, time and cost.

    Coming

    Where it stopsThe same instructions are written out again for every task.

  3. Part 3Skills

    Skills: Turning Good Instructions into Reusable Expertise

    How do you stop rewriting the same instruction?

    When a good instruction should become a skill, what goes into one, and how a house style for every channel is written once and loaded when needed.

    Coming

    Where it stopsYou still drive every step yourself.

  4. Part 4Agents

    What Makes an Agent: Tools, Observation and the Loop

    What changes when the model picks its own steps and tools?

    Tools, observation and the loop: what changes when the model chooses its own steps, counting characters and spoken seconds and checking every figure as it goes.

    Coming

    Where it stopsIt stops when the text looks finished, not when the work is done.

  5. Part 5Goals

    Goal-Directed Agents: Defining Done and Knowing When to Stop

    How does an agent keep working until the work is done?

    A goal in place of a plan: defining done as checks every piece must pass, and how an agent knows when to stop.

    Coming

    Where it stopsOne context fills up, and one thread is slow.

  6. Part 6Sub-agents

    Delegation: When One Agent Should Hand Work to Others

    When should one agent hand work to others?

    When one agent should hand work to others: a sub-agent for each channel and one that checks the facts, and what the split costs.

    Coming

    Where it stopsThe plan changes from run to run.

  7. Part 7Workflows

    Orchestration: Workflows That Run Many Agents Reliably

    How do many agents work to a fixed plan?

    Code that runs many agents in a fixed structure: a weekly job that turns each new source into every channel, the same way every time.

    Coming

References

1 source: 1 working paper ShowHide
  1. 1

    How people use ChatGPT

    A. Chatterji, T. Cunningham, D. J. Deming, Z. Hitzig, C. Ong, C. Y. Shan, and K. Wadman

    National Bureau of Economic Research, Working Paper 34255, Sep. 2025

    Working papernber.org