01 est. 20 min Free preview

Foundations: what an agent actually is

Module 01 · Free preview · est. 20 min · You’ll walk away with: the one mental model that separates a chatbot from a production agent — and a checklist to tell which one you’re actually building.

TL;DR: An agent isn’t a smarter chatbot. It’s a loop: a model that decides, tools that act, and a trigger that fires without you. If your “agent” can’t take an action in the real world and can’t run when you’re asleep, it’s a chatbot with a costume on. This lesson gives you the model I use to design every one of the 30+ agents I run in production — strip out the marketing, and the whole thing fits on an index card.

[Operator’s read] I’m writing this from inside the agent systems that actually run my businesses — a pickleball facility in Texas, a handful of content sites, my own inbox. Not a demo I built for a slide. What follows is the model I wish someone had handed me before I wasted three weekends building things that didn’t work.

Why this lesson is free

Because if I can’t teach you the foundations in 20 minutes and have you nodding, you shouldn’t pay me for the other seven modules. This is the filter. Read it, build the mental model, and decide if the rest is worth $199. (It is. But you tell me.)

Here’s the thing nobody selling you an “AI course” wants to admit: most of what gets called an “AI agent” in 2026 is a chatbot with better marketing. A box you type into, it types back, the end. That’s not an agent. That’s autocomplete with a personality.

An agent is a different animal. And once you see the difference, you can’t unsee it — and you’ll stop wasting money on tools that promise “agentic AI” and deliver a glorified FAQ.

The definition, stripped of the marketing

An agent is three things in a loop:

A model that decides — the LLM (Claude, in my case) that looks at a situation and picks what to do next.
Tools that act — code the model can call to do something real: send an email, post to Instagram, read a database, hit an API, run a shell command.
A trigger that fires — the thing that starts the loop without a human babysitting it. A cron schedule. A webhook. A new row in a table. A 7am alarm.

That’s it. Decide, act, fire. If you have all three, you have an agent. If you’re missing one, you have something else:

Model + tools, but no trigger = a copilot. Useful, but it only runs when you’re sitting there poking it. (This is most of what people call “agents.” It’s Claude Code waiting for you to type.)
Model + trigger, but no tools = a scheduled chatbot. It can think on a timer but can’t do anything. Generates a report nobody asked for, into a void.
Tools + trigger, but no model deciding = a plain old script. A cron job. Zapier. Fine! But there’s no intelligence in the loop — it does the exact same thing every time, and the second reality changes shape, it breaks.

The magic — the reason agents are a genuinely new category and not hype — is the combination. A model deciding, with real hands, on its own schedule. That’s an employee who works for fractions of a cent and never sleeps.

The chatbot vs. agent test (memorize this)

Two questions. Ask them about anything calling itself an agent:

Question 1: Can it take an action in the real world that outlives the conversation?

Not “can it write me an email.” Can it send the email. Can it move money, change a record, publish a post, file a ticket, place an order. If the only output is text on your screen that you then have to act on yourself, it’s a chatbot. The action is the whole point. Text is cheap. Consequence is the product.

Question 2: Can it run when I’m asleep?

If the answer requires you to be present — to click “go,” to paste context, to approve each step — you have a copilot, not an agent. Copilots are great. I live in one (Claude Code) all day. But the leverage of an agent comes from it firing on its own. My morning brief agent runs at 6am whether I’m awake or not. My LMNT reorder agent notices I’m low and reorders before I think about it. That’s the unlock.

Run anything through those two questions and you’ll instantly know what you’re dealing with. Most “AI agent” SaaS fails both. A lot of “agents” people are proud of fail the second one — they’re copilots, and that’s fine, just call it what it is.

The mental model that scales: the loop

Here’s the index-card version. Every agent I run, no matter how complex, is this loop:

code

TRIGGER fires
  → AGENT gathers context (reads the world)
    → MODEL decides what to do
      → TOOLS execute the action
        → AGENT checks the result
          → repeat until done, or stop and report

Read it again. Trigger, context, decide, act, check, repeat. That’s the skeleton of every agent on earth, from my “reply to Google reviews” agent to the trading systems hedge funds run. The difference between a toy and a production system is not the loop — it’s how well each step is built.

Let me make it concrete with one of mine. My Pickleland event-promo agent:

Trigger: runs on a schedule, a few days before events.
Context: reads our event calendar from PlayByPoint (our booking system), sees what’s coming up with open seats.
Decide: the model figures out which events need promotion, what the angle is, which audiences to hit.
Act: drafts a bundled email, drafts targeted Facebook group posts matched to each event.
Check: it stops there and hands me drafts. Nothing sends without my “yes.”
Repeat: next run, it does it again, learning nothing it doesn’t need to.

Notice the check step ends in a human gate. That’s a design choice, not a limitation. Some of my agents send straight to production (my morning brief, my AI-trends digest — low stakes, just for me). Others draft and wait (anything that talks to customers or spends money). Knowing where to put the human gate is half the skill, and it’s Module 06.

The three things beginners get wrong

I’ve now built and rebuilt enough of these to see the same three mistakes every time. Avoid them and you’re ahead of 90% of people calling themselves “AI engineers.”

Mistake 1: Trying to build one agent that does everything.

The instinct is to build “an AI assistant for my business.” Don’t. That agent will be mediocre at twelve things and break constantly. The winning move is one agent, one job. My event-promo agent promotes events. It doesn’t also answer DMs or reorder supplements. Each of my 30+ agents is embarrassingly narrow. Narrow is why they’re reliable. (Module 03 is entirely about this — the four shapes a narrow agent takes, and the trap of trying to be all four.)

Mistake 2: Confusing “it works once” with “it works.”

You’ll build something, run it, it’ll work, and you’ll feel like a genius. Then it’ll run the next day with slightly different input and produce garbage. An agent that works once is a demo. An agent that works the 200th time, on input you didn’t anticipate, is a product. The gap between those is evals, error handling, and monitoring — the unsexy stuff (Modules 04 and 06) that separates people who talk about agents from people who run them.

Mistake 3: Thinking the model is the hard part.

It isn’t. The model (Claude) is the easy part — it’s genuinely smart, it’s cheap, and it gets better every few months for free. The hard part is everything around it: giving it the right context, the right tools, the right guardrails, and a place to run. You will spend 10% of your time on prompts and 90% on plumbing. That’s the job. If a course is all “prompt engineering” and no plumbing, it’s teaching you the 10% and skipping the part that makes money.

You don’t need Python (and other liberating facts)

Let me clear some debris that keeps beginners stuck.

You don’t need Python. Everyone assumes AI work means Python. I don’t write Python. I run my entire agent fleet on TypeScript, shell scripts, and prompt files. That’s it. If you can write a bash script and read a bit of TypeScript, you can build everything in this course. (Why? Because my world is web — Cloudflare, Astro, GitHub Actions — and TypeScript lives there natively. Use the language your infrastructure already speaks.)

You don’t need a GPU, a vector database, or “fine-tuning.” Those are answers to problems you don’t have yet. For 95% of real business agents, you call an API and you’re done.

You don’t need a CS degree. You need to understand the loop and be willing to debug. That’s a craftsman’s skill, not an academic one.

You don’t need to “train a model.” You’re not building the model. You’re directing one that already exists, the way a manager directs a very fast, very literal employee. Your job is delegation, not machine learning.

What “production” actually means

I keep saying “production agent” like it’s a special thing. It is. A production agent has four properties a demo doesn’t:

It runs on a trigger you didn’t fire. Cron, webhook, event. Not your finger.
It handles inputs you didn’t anticipate without face-planting. The calendar’s empty? It says so and stops. The API’s down? It retries or reports. It doesn’t hallucinate a confident wrong answer.
It tells you when it’s wrong (or when it’s unsure). It has a way to flag low confidence and escalate to a human. An agent that fails silently is worse than no agent.
You can see what it did. Logs. A report. A Slack message. If an agent runs and you can’t tell what happened, you don’t have an agent — you have a liability.

Hold those four up against any “agent” demo on Twitter. Most have zero of them. They’re impressive on stage and useless on Monday.

Hands-on lab

You don’t need to build anything yet — that’s Module 02. For this lab, you’re going to think like an operator, which is the actual prerequisite.

Step 1 — Audit your day. Open a note. List every recurring task in your business that (a) follows a pattern, (b) takes you under an hour, and (c) you do at least weekly. Don’t filter yet. I want 10+ items. (Mine, early on: “promote upcoming events,” “reply to reviews,” “summarize last week’s marketing numbers,” “reorder supplements I keep forgetting.”)

Step 2 — Run each through the two-question test. For each task, ask: Does it require an action in the real world? and Could it run while I sleep? Mark the ones that score yes/yes. Those are your agent candidates. The ones that need your judgment in the moment are copilot candidates — still useful, but different.

Step 3 — Map your top candidate to the loop. Pick the single best yes/yes task. Write out its loop on one line each:

Trigger: what would kick this off?
Context: what does it need to read first?
Decide: what’s the judgment call?
Act: what’s the real-world action?
Check: how would you know it worked — and where’s the human gate?

If you can fill in all five lines, congratulations: you’ve just designed your first agent. In Module 02 you’ll build exactly this one, in 30 minutes, by copying a repo I hand you. Keep this note — it’s your spec.

What’s next

You now have the model. Here’s what the paid modules turn it into:

Module 02 — Your first agent in 30 minutes. Copy my starter repo, wire it to Claude, and ship the agent you just spec’d. Working code, today.
Module 03 — The four agent patterns that ship. Polling, event-triggered, scheduled, conversational. Pick the right shape so you never build the wrong thing.
Module 04 — Memory, tools, evals. Give your agent a memory that survives restarts, hands that don’t break, and a way to know when it’s wrong.
Module 05 — Prompting for production. Why the prompts you write for ChatGPT collapse the moment they run unattended — and the structure that doesn’t.
Module 06 — Cost, latency, security. The three things that kill an agent before features ever do. Where to put the human gate. How to not wake up to a $4,000 bill.
Module 07 — Shipping it. Cloudflare Workers, Pages Functions, GitHub Actions, cron. The boring infra that makes agents actually run.
Module 08 — Case studies: my 30+ agents. Every agent I run in production, broken open. The wins, the failures, the rebuilds. Steal what you need.

Six hours. One weekend. The same playbook running my businesses right now. If you finish Module 01 and don’t think the rest is worth it, the refund button is right there. But I think you already know which yes/yes task you’re going to automate first.

Enroll, and let’s build it.