Introduction: The Age of Agents

For most of computing history, software did exactly what it was told. A spreadsheet calculated what you entered. A search engine returned pages matching your query. Every outcome was a direct, predictable consequence of a human instruction.

Then came large language models — systems trained on vast amounts of human text that could generate coherent, contextually aware responses to open-ended questions. That was remarkable. But an AI agent goes further: it sets intermediate goals, uses tools, observes results, adapts its plan, and keeps going until the job is done.

Why Now?

Several developments converged around 2024–2025 to make practical AI agents possible for non-engineers:

• Model intelligence crossed a threshold where models reliably follow complex, multi-step instructions.
• Tool use became standardized: models can now call APIs, browse the web, read files, write code, and control browsers using protocols like MCP.
• Agentic platforms (Codex, Claude Code, Anti-Gravity) wrapped these capabilities in consumer-friendly interfaces.
• Parallelization allowed multiple agents to work simultaneously, compressing days of work into minutes.

What Can Agents Actually Do?

What This Book Will Teach You

By the end of this guide you will understand:

1. How agents think and act (the core loop)
2. Which platform to choose and why
3. How to write prompts that produce consistent, high-quality results
4. How to orchestrate multiple agents working in parallel
5. How to control costs without sacrificing quality

Core Concepts: How Agents Think

Before you can direct an AI agent effectively, you need to understand what is happening inside it. This chapter demystifies the agent's internal process — a simple three-step loop that repeats until the job is done — and explains why that loop is so powerful.

1.1 The Core Agent Loop

Every AI agent, regardless of which platform or model powers it, executes the same fundamental cycle. Researchers at Google DeepMind and Stanford have formalized variants of this cycle under names like ReAct ^[5] and Reflexion ^[7], but the intuition is simple:

Step 1 — Observe

The agent reads everything available to it. This includes:

• Your original instruction (the prompt)
• Any files, documents, or data you provided
• The results of previous tool calls (web searches, code execution, etc.)
• Its own memory files (claude.md, gemini.md, agents.md)
• Multimodal data — images, audio, video frames — if applicable

All of this information sits in the agent's context window — a finite memory space that grows with each loop iteration.

Step 2 — Think

The agent reasons about what to do next. Modern platforms expose this reasoning step visually: you can literally read the agent's mini-plan before it acts. This interpretability is one of Claude Code's standout strengths.

Step 3 — Act

The agent executes its plan. Common actions include:

• Tool calls: searching the web, reading a file, calling an API
• Code execution: writing and running a script
• Browser control: navigating a webpage, filling a form, clicking a button
• File editing: creating or modifying documents

After the action completes, its result is fed back into the Observe step, and the loop begins again — now with a slightly fuller context window.

The Definition of Done

The loop continues until the agent decides the task is complete. This decision is governed by the Definition of Done — the set of success criteria you specify in your prompt. This is the single most overlooked element in beginner prompting, and its absence is the primary reason people feel underwhelmed by agent results.

1.2 Agent Architecture: More Than a Model

A common misconception is that an AI agent is just a chatbot with a fancier interface. In reality, the LLM is only one component of a larger system. Think of the LLM as the brain: capable and intelligent, but helpless without a body.

This architecture is why the term agent — rather than chatbot — is appropriate. An agent is embedded in an environment, observes that environment, and takes actions to change it toward a desired goal.^[6]

1.3 The Growing Context Window

Each time the loop completes one cycle, the result of the action is added to the context. Imagine a notepad that gets a new line after every step. By the fifth loop, the agent has five lines of context: its original instructions, the result of step 1, the result of step 2, and so on.

This is both a strength (the agent accumulates knowledge) and a constraint (the notepad has a maximum size). Context management — deciding what to keep, what to summarize, and what to discard — is one of the core skills covered in Chapter 6.

The Three Platforms

Three major platforms dominate the agentic coding landscape as of mid-2025. Each wraps a world-class LLM in a purpose-built interface for autonomous work. Understanding their differences — and their surprising similarities — will help you choose the right tool for each job.

2.1 The Big Picture

2.2 Claude Code — The Orchestrator

Claude Code's greatest strength is interpretability. Its reasoning tab shows you, in plain language, exactly what the model is planning to do before it does it. This makes Claude ideal as an orchestrator — the top-level manager that delegates work to other models and reviews their results.

2.3 Anti-Gravity (Gemini) — The Designer

Gemini's standout feature is its native video understanding. Unlike Claude and GPT, Gemini can process video at the API level — analyzing frames, extracting steps, and executing what it watches. It also consistently produces the most visually polished frontend designs.

2.4 Codex (GPT) — The Engineer

The GPT model series excels at backend development, rigorous mathematics, and test-driven development. Its "fire and forget" style — point it at a target, let it run — suits tasks with a clear, verifiable Definition of Done.

2.5 Getting Started

Prompting Techniques

Prompting is the primary interface between you and an agent. A well-structured prompt is the difference between an agent that wanders and one that executes with surgical precision. This chapter covers four high-leverage techniques: self-modifying system prompts, agent skills, prompt contracts, and reverse prompting.

3.1 Self-Modifying System Prompts

Every major platform provides a special file that is automatically prepended to every conversation. This file goes by different names depending on the platform:

Because this file is read at the start of every session, it functions as a persistent, growing memory. The key insight is to instruct the agent to update this file automatically whenever you correct it — turning your feedback into permanent rules.

Over time, this creates a compounding improvement. After one session you have one rule; after ten sessions you have ten rules; after fifty sessions your agent almost never makes mistakes relative to your preferences.

3.2 Agent Skills

An agent skill is a reusable workflow stored as a markdown file. Where the system prompt file captures your preferences, a skill captures a process. Skills transform the LLM's natural statistical variability into a predictable, deterministic workflow.

A skill file has two parts: a short YAML header (loaded into context every session) and a detailed body (loaded only when the skill is invoked):

3.3 Prompt Contracts

A prompt contract is a structured agreement between you and the agent, established before any work begins, that defines four things:

3.4 Reverse Prompting

Reverse prompting takes prompt contracts one step further. Instead of having the agent generate the contract directly from your vague instruction, it first asks you five clarifying questions — surfacing assumptions and preferences you might not have known to mention. Only after you answer does it draft the contract.

The practical benefit is dramatically improved one-shot potential — the probability the agent gets it right on the first try, with no corrections needed.

Multi-Agent Strategies

A single agent is impressive. A coordinated fleet of agents is transformative. This chapter covers the four multi-agent design patterns that separate casual users from power users: MCP orchestration, stochastic consensus, agent chat rooms, and sub-agent verification loops.

4.1 Multi-Agent MCP Orchestration

MCP orchestration uses one model as a manager that delegates subtasks to specialist sub-agents. Each sub-agent is chosen for its comparative advantage:

The orchestrator decomposes the task, routes each piece to the best model via MCP server calls, then collects and validates results. This approach has two advantages: the best model handles each subtask, and sub-agents work in parallel, reducing total completion time.

4.2 Stochastic Multi-Agent Consensus

LLMs are stochastic: ask the same question twice and you get slightly different answers. Most users treat this as a bug. Power users treat it as a feature.

Stochastic consensus works by spawning N agents simultaneously, each with a slightly different prompt framing, then aggregating their outputs. The result traverses far more of the "answer space" than any single query.

The aggregated report categorizes findings into three tiers:

• Consensus items: Ideas that multiple agents independently surfaced — high confidence, act on these.
• Divergent items: Ideas supported by some agents but not others — worth careful evaluation.
• Outliers: Ideas from only one agent — potentially brilliant, potentially hallucinated.

4.3 Agent Chat Rooms

Where stochastic consensus runs agents in parallel isolation (they don't communicate), agent chat rooms run agents in a shared debate. Each agent is assigned a distinct personality, and they argue about the problem in a shared chat.json file.

The debate sharpens ideas: agents push back on each other's weak points, surface hidden assumptions, and converge on more nuanced answers than any single agent could produce. The resulting chat.json log serves as valuable context for an orchestrator's final synthesis.

4.4 Sub-Agent Verification Loops

When an agent spends a long time building something, it develops a kind of sunk-cost bias: it has explored many dead ends, made many decisions, and accumulated a sense that its approach was the best one. Ask that same agent to critique its own work and it will find remarkably little wrong with it.

The solution is to pass the output only — stripped of all reasoning history — to a fresh agent that has never seen the problem before.

The reviewer evaluates for four dimensions: correctness, edge cases, simplification opportunities, and security vulnerabilities. Because it sees only the output — not the journey to get there — it catches errors the implementer is blind to. This is conceptually identical to peer review in academic publishing.^[3]

Advanced Pipelines

5.1 Video-to-Action Pipeline

Until recently, agents could only learn from text. A YouTube tutorial — rich with visual context, cursor movements, and UI navigation — was opaque to any model. The video-to-action pipeline changes this by routing video through Gemini's native video understanding API.

Gemini samples the video at one frame per second, analyzes the image sequence, and produces a hyper-specific numbered step list (e.g., "At 0:17, click the blue 'Add Node' button in the top-left toolbar"). Claude receives this list and executes each step using browser control, file editing, or other tools.

5.2 Multi-Agent Chrome Automation

The Chrome DevTools MCP server lets an agent control a real browser: navigate pages, click elements, fill forms, take screenshots, and read page content. A single agent performing these actions sequentially is useful. Ten agents performing them in parallel is transformative.

The throughput math is compelling. If a single agent takes 2–3 minutes per form submission, one agent processes ~0.5 forms/minute. With 10 agents: 5 forms/minute. With 100 agents: 50 forms/minute. A list of 2,000 contacts processed in under an hour.

The Shared Chat File Pattern

Coordinating N agents requires a communication mechanism. The simplest and most reliable approach is a shared chat.json file in a central workspace folder. The orchestrator resets this file at the start of each run. Each sub-agent appends its status, results, and any issues every 30 seconds. The orchestrator polls the file periodically and re-routes work as needed.

Cost & Optimization

AI agents are not free. Every token processed costs money, and complex multi-agent workflows can accumulate costs quickly. This chapter covers two interrelated topics: managing the context window to maintain output quality, and structuring model usage to minimize cost without sacrificing results.

6.1 Why Quality Degrades Over Time

As a conversation grows, so does the context window. And as the context window grows, model performance measurably declines. This is not speculation — it is a documented phenomenon in large language model research^[2] sometimes called "lost in the middle": models attend less effectively to information buried deep in a long context.

6.2 Context Compaction

When the context window approaches its limit, the platform automatically triggers compaction: a summarization process that compresses old context into fewer tokens. Think of it as a hydraulic press squishing older parts of the conversation into dense summaries.

Compaction preserves meaning but loses precision. Specific tool outputs, exact error messages, and nuanced reasoning steps may be reduced to one-line summaries. For long-running agentic tasks, this can cause subtle regressions.

6.3 The Iceberg Technique

The iceberg technique is the leading approach to strategic context management. The idea: keep only a small amount of information immediately loaded in the context window, and give the agent tools to access everything else on demand.

6.4 Model Selection Strategy — The 60/30/10 Rule

Not every subtask requires your most powerful (and expensive) model. The 60/30/10 rule provides a practical allocation framework:

6.5 Batch API Pricing

All major providers offer a Batch API that processes requests asynchronously during off-peak server hours. In exchange for accepting up to 24-hour latency, you receive approximately 50% off standard pricing. For high-volume, non-time-sensitive workloads (overnight research, bulk data processing), the batch API can halve your monthly AI costs.

Real-World Applications

Everything in Chapters 1–6 was preparation. This chapter is where you actually do things. We will walk through four complete, real-world applications — from your very first agent setup to running a multi-agent virtual company, automating repetitive jobs, and producing research-grade written work. Every step is explained, illustrated, and shown in full.

7.1 Setting Up Your First Agent Task

This section is for the complete beginner. We are going to build a working agent setup from scratch — step by step, with no assumed knowledge. By the end, your agent will autonomously perform a real task while you watch.

Step 1 — Open Claude Code and Choose a Folder

Think of a folder on your computer the same way you think of a desk drawer. Your agent works inside that drawer — it can read, write, and organise files there, but it cannot reach outside unless you give it permission.

Step 2 — Create Your Memory File

Before giving the agent any task, set up your claude.md — the persistent memory file from Chapter 3. This is a plain text file you create once and the agent reads forever.

Step 3 — Give Your First Real Task

Now let us give the agent a task with a proper Definition of Done — the most important lesson from Chapter 1. We will ask it to research a topic and produce a structured report.

Step 4 — Correct and Improve

When the agent finishes, read the report. If anything is not to your liking, correct it in plain English:

The agent will fix the report and write a new rule into claude.md. You have now completed your first full agent learning cycle.

7.2 Running a Virtual Company with Multi-Agents

A virtual company is a group of specialised AI agents that each handle one department — just like a real business. One agent handles marketing, another handles operations, another handles finance, and a manager agent oversees and coordinates them all. Together they can accomplish in a few hours what would take a small human team days.

The Blueprint: A Four-Department Virtual Company

Step-by-Step: Setting Up Your Virtual Company

Step 1 — Create the Company Folder Structure

Step 2 — Write the Company Briefing

The briefing is the single document every agent reads first. It tells them who they are, what the company does, and what the current goal is.

Step 3 — Create Agent Identity Files

Each agent gets its own claude.md-style identity file inside its folder. This is what makes each agent behave differently from the others.

Step 4 — Run Your First Multi-Agent Task

Now open Claude Code and run the CEO agent. Give it a real company task and watch it delegate:

Scaling Up: True Parallel Agents

Once you are comfortable with one-at-a-time delegation, you can run real parallel agents by opening multiple Claude Code windows simultaneously, each pointed at a different department folder. All four run at the same time, writing to chat.json as they go. The CEO window monitors the chat log and synthesises when all departments report completion.

7.3 Automating Routine Jobs

Routine jobs are the best first target for AI agents — they are repetitive, well-defined, and the Definition of Done is obvious. This section shows you how to automate five common professional tasks completely.

Routine Job 1 — Weekly Email Digest

Scenario: Every Monday morning you want a summary of emails received the previous week, organised by priority.

Routine Job 2 — Meeting Preparation Brief

Before any important meeting, an agent can prepare a one-page brief — background on attendees, agenda summary, suggested questions, and relevant context from your files.

Routine Job 3 — Social Media Content Calendar

Creating a month of social media content is one of the most time-consuming marketing tasks. An agent can produce a complete 30-day calendar in minutes.

Routine Job 4 — Financial Expense Report

If you keep receipts or expense logs in a folder, an agent can read them and produce a formatted expense report automatically.

Routine Job 5 — Competitive Intelligence Monitor

Stay ahead of competitors by running a weekly intelligence sweep.

7.4 Research and Producing Publishable Papers

This is the most sophisticated application in the chapter. We will walk through how to use AI agents to produce rigorous, well-structured academic or professional research papers — and how to ensure the writing is genuinely original, not plagiarised.

Why AI-Written Text Can Fail Plagiarism Detectors — and Why That Is Not Enough

AI text is not plagiarised in the traditional sense — it does not copy sentences from existing sources. However, AI detectors (Turnitin's AI detection, GPTZero, Originality.ai) look for statistical patterns in writing: unnaturally consistent sentence length, predictable word choices, and absence of the "noise" that human writing naturally contains.

The strategies below produce writing that passes these detectors not by tricking them, but by producing genuinely high-quality, original, analytically rich text that reflects real thinking.

The Six-Stage Research Pipeline

Stage 1 — Scoping (Define the Research Question)

Never let the agent choose your research question. You define it. The agent helps you refine it into something researchable and specific.

Stage 2 — Source Gathering

Use the Research Agent pattern to gather sources. Crucially, instruct the agent to save raw source information separately from its interpretation of that information.

Stage 3 — Synthesis (Finding the Argument)

Synthesis is the most intellectually demanding step — and the one most likely to produce genuinely original content, because it requires the agent to find patterns and tensions across sources.

Stage 4 — Drafting

Now write the paper section by section. Writing it in sections (rather than all at once) produces better, more focused output and reduces the statistical AI-writing patterns that detectors flag.

Stage 5 — Humanisation

This is the stage that makes the difference between text that reads as AI-generated and text that reads as a human scholar. Humanisation does not mean hiding AI use — it means elevating the quality to genuine human-level writing.

Stage 6 — Verification

Before submitting, run a final verification using a fresh sub-agent with no context of how the paper was written:

Assembling and Exporting the Final Paper

Conclusion: Putting It All Together

You have now covered the full arc of practical AI agent mastery — from the three-step loop that powers every agent, to the multi-agent architectures that compress weeks of work into hours, to the cost optimization strategies that make serious deployment economically viable.

The Hierarchy of Skills

Think of everything you have learned as a hierarchy, where each layer builds on the one below:

A Recommended Learning Path

1. Week 1: Set up one platform (Claude Code recommended). Give it 10 different real tasks. Observe the loop. Add a Definition of Done to each prompt.
2. Week 2: Create your first claude.md with 5 rules. Correct the agent 3 times and verify the corrections are written to the file. Build your first agent skill.
3. Week 3: Run your first prompt contract and reverse prompting session. Notice the difference in output quality.
4. Week 4: Attempt a simple two-agent setup: one agent builds, another reviews. Run a stochastic consensus with 5 agents on a decision you have been putting off.
5. Month 2+: Build a domain-specific skill library. Implement the 60/30/10 model rule. Explore Chrome automation for a real outreach or research task.

The Bigger Picture

AI agents are shifting the nature of knowledge work. Tasks that required a team — research, drafting, coding, quality review, outreach — can increasingly be accomplished by one person with a well-orchestrated fleet of agents. This is not a threat to thoughtful human judgment; it is an amplifier of it.

The practitioners who will thrive are not those who use agents blindly, but those who understand the architecture deeply enough to direct, verify, and correct agent work with authority. That is what this book aimed to give you.

Thank you for reading. Continue to the Bibliography for academic references.

Bibliography

• [1] Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., & Polosukhin, I. (2017). Attention is all you need. Advances in Neural Information Processing Systems, 30. https://arxiv.org/abs/1706.03762
• [2] Liu, N. F., Lin, K., Hewitt, J., Paranjape, A., Manning, C. D., Hashimoto, T., & Liang, P. (2023). Lost in the middle: How language models use long contexts. Transactions of the Association for Computational Linguistics. https://arxiv.org/abs/2307.03172
• [3] Madaan, A., Tandon, N., Gupta, P., Hallinan, S., Gao, L., Wiegreffe, S., … & Clark, P. (2023). Self-Refine: Iterative refinement with self-feedback. Advances in Neural Information Processing Systems, 36. https://arxiv.org/abs/2303.17651
• [4] Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., … & Zhou, D. (2022). Chain-of-thought prompting elicits reasoning in large language models. Advances in Neural Information Processing Systems, 35. https://arxiv.org/abs/2201.11903
• [5] Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2023). ReAct: Synergizing reasoning and acting in language models. International Conference on Learning Representations (ICLR). https://arxiv.org/abs/2210.03629
• [6] Park, J. S., O'Brien, J. C., Cai, C. J., Morris, M. R., Liang, P., & Bernstein, M. S. (2023). Generative agents: Interactive simulacra of human behavior. Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology. https://arxiv.org/abs/2304.03442
• [7] Shinn, N., Cassano, F., Berman, E., Gopinath, A., Narasimhan, K., & Yao, S. (2023). Reflexion: Language agents with verbal reinforcement learning. Advances in Neural Information Processing Systems, 36. https://arxiv.org/abs/2303.11366
• [8] Wu, Q., Bansal, G., Zhang, J., Wu, Y., Li, B., Zhu, E., … & Wang, C. (2023). AutoGen: Enabling next-gen LLM applications via multi-agent conversation. arXiv preprint. https://arxiv.org/abs/2308.08155
• [9] Sterling, S. (2025). Autonomous Blender tutorial replication via YouTube video understanding. Post on X (formerly Twitter). [Social media post demonstrating video-to-action agent pipeline for 3D modeling tutorial execution.]
• [10] Jiang, A. Q., Sablayrolles, A., Roux, A., Mensch, A., Savary, B., Bamford, C., … & Sayed, W. E. (2024). Mixtral of experts. arXiv preprint. https://arxiv.org/abs/2401.04088
• [11] Anthropic. (2025). Claude model documentation and API reference. Anthropic Technical Documentation. https://docs.anthropic.com
• [12] OpenAI. (2025). Codex and GPT-4 API documentation. OpenAI Platform Documentation. https://platform.openai.com/docs
• [13] Google DeepMind. (2025). Gemini model family technical report. Google AI. https://deepmind.google/technologies/gemini
• [14] Wang, L., Ma, C., Feng, X., Zhang, Z., Yang, H., Zhang, J., … & Wen, J.-R. (2024). A survey on large language model based autonomous agents. Frontiers of Computer Science. https://arxiv.org/abs/2308.11432
• [15] Yerkes, R. M., & Dodson, J. D. (1908). The relation of strength of stimulus to rapidity of habit-formation. Journal of Comparative Neurology and Psychology, 18(5), 459–482. [Foundation for the inverted-U performance curve referenced in Chapter 6.]