AI Agents & Automation

Kaern Schools — Flagship "AI for Business" Course

Taught on the real cycleX agent stack: Claude API, tool-use, agent orchestration, the OutreachPro and marketing/sales/manufacturing autonomy playbooks, and Kaern's own Brain knowledge repository.

Your tutor: Ada — practitioner, builder, and your guide through this course.

How to use this material

This is a taught course, not a manual. Each module gives you what Ada says in the room, a real cycleX worked example, something to build with your own hands, the mistakes that bite everyone, and a quick self-check. Read the teaching scripts as if Ada is speaking — because they are written exactly as she delivers them.

Course shape (7 modules):

1. How LLMs & context windows actually work
2. Prompting & structured outputs
3. Tool use & function calling
4. Agent orchestration & multi-agent workflows
5. Memory & knowledge repositories (the Brain)
6. Evaluation, safety & guardrails
7. Shipping agents into a real business (autonomy playbooks)

Then: a Capstone project and an Assessment rubric.

A note on philosophy before we begin. Throughout this course Ada repeats one idea: an agent is a model plus tools plus a loop, working toward a goal under guardrails. Everything else is detail. Hold onto that sentence — we'll keep returning to it.

Module 1 — How LLMs & Context Windows Actually Work

Learning objectives

• Explain, in plain language, what a large language model does at each step (next-token prediction) and why that matters for reliability.
• Describe the context window as a finite working memory and reason about what to put in it.
• Distinguish between a model's parameters (frozen knowledge) and its context (what it can see right now).
• Predict common failure modes — hallucination, "lost in the middle," and context overflow — from first principles.
• Estimate roughly how much text fits in a window using the token mental model.

Lesson 1.1 — The prediction engine

Teaching script (Ada speaks):

"Let me start by dismantling a myth. When you talk to Claude, it is not looking things up. There's no little librarian inside fetching facts. At its core, the model does one thing astonishingly well: given all the text so far, it predicts the next chunk of text — what we call a token. Then it does it again. And again. That's it. That's the engine.

Now, why should a business person care about plumbing? Because almost every frustration you'll ever have with an agent traces back to this one fact. The model is fluent, not truthful. Fluency and truth usually travel together, which is why it feels magical — but they can come apart, and when they do, you get a confident, beautifully-worded wrong answer. We call that a hallucination.

Think of it like a brilliant improv actor. Give them a strong scene and good cues, and they're spectacular. Give them a vague prompt and they'll still perform — they'll invent a plausible scene, because performing is what they do. Your job, as the person building the agent, is to be the director: set the scene so precisely that the most fluent continuation also happens to be the correct one.

So here's my question to you before we go further: if the model is always just predicting the next token, where do you think its knowledge actually lives — and what's the difference between that and the information you hand it in a prompt?"

Lesson 1.2 — The context window as working memory

Teaching script (Ada speaks):

"Good. Now hold those two things apart in your mind: there's the model's trained-in knowledge — frozen, baked in months ago, vast but stale — and there's the context window, which is the model's working memory for this exact conversation. The context window is everything the model can see right now: your instructions, the conversation history, documents you pasted, tool results that came back. It is finite. Think of it as the model's desk.

A small desk forces you to be tidy. A large desk lets you spread out — but here's the trap nobody tells you: a bigger window doesn't mean the model reads everything equally well. There's a well-documented effect we call lost in the middle — models attend most reliably to the start and the end of the context, and content buried in the middle of a very long window gets fuzzy. So 'just paste everything in' is not a strategy. It's how you get an agent that ignores the one paragraph that mattered.

At cycleX we treat context like prime real estate. Every token we spend on irrelevant history is a token not spent on the customer's actual question. This is why memory and retrieval — Module 5 — exist at all: to put the right small thing on the desk instead of the whole warehouse.

Here's my question: if you had to brief a freelancer who forgets everything between emails, and you could only send one page, what would you put on it — and what does that tell you about designing context?"

Worked example — cycleX OutreachPro context budget

OutreachPro drafts personalized B2B outreach for cycleWASH's bicycle-washing systems. A naïve build stuffed the entire product catalogue, every past email, and the full company wiki into each prompt. Result: 18,000-token prompts, slow responses, and the model frequently citing the wrong product (recommending the Pro Platinum to a customer who'd asked about the compact Mini Platinum).

The fix was a context budget:

Total dropped to ~1,800 tokens. Accuracy on "correct product mentioned" rose sharply because the right facts were no longer drowning in the middle of a wall of text.

Hands-on exercise

Take any document you know well (a product sheet, a policy, an FAQ). Without tools, write a one-page brief that a "forgetful freelancer" could use to answer the five most common customer questions. Then count: roughly how many words is it? Multiply by ~1.3 to estimate tokens. Reflect: what did you leave out, and why was that the hard part?

Common mistakes

1. Treating the model as a database. Asking "what's our refund policy?" expecting a lookup — when the policy was never put in context. The model will invent one.
2. The "paste everything" reflex. Assuming more context = better answers. It often buries the signal and triggers lost-in-the-middle failures.
3. Confusing trained knowledge with current facts. Trusting the model on prices, dates, or inventory it was never told — its training data is frozen and stale.

Check for understanding

1. In one sentence, what is the single operation a language model performs repeatedly?
2. Why can a model be highly fluent and still completely wrong? Give a business example.
3. You have a 200,000-token window. Name two reasons you still wouldn't fill it.