You’re Not Behind (Yet): How to Build Your First AI Agent (Full Guide)

Technological concepts & product/solution features

AI Chatbot vs AI Agent

• Chatbot: behaves like an interactive “meeting”—you ask a question and wait for an answer.
• Agent: behaves like an “employee”—you specify a goal, and the agent runs a full workflow with the ability to act and verify results.

Agent behavior is described as a loop (continuous improvement):

1. Diagnose (D): figure out what’s wrong and solve it
2. Assemble (A): build plans/tools to complete tasks
3. Take action (T): execute tasks (not just talk)
4. Assess (A): check its work and improve if needed

Without the loop, it’s just automation (does a job and stops).

Rule of R: decide if an agent is worth it

Use this to evaluate whether building an agent pays off:

• Repetitive: do it every week?
• Rules-based: same input → same output pattern?
• Return on time: does building the agent save more time than doing the work manually?

Agent-building framework (“AGENT” acronym)

A = Aim for a specific outcome

• Define the outcome clearly (one-sentence target).
• Use “why before how”: explain purpose so the agent can decide smarter.
• Define a Definition of Done (DoD) with measurable/clear criteria.
• Use reverse prompting: state desired results, then let the AI ask clarifying questions and generate the plan.

G = Give it an identity

• Identity makes the model specialize instead of being “general.”
• Example: removing identity/rule books from a customer-support agent reduced success 33% → 11% (same model/task/request).

Identity is created using three plain-English files:

1. Soul file (personality/behavior style: tone, quirks, values)
2. Identity file (role/“DNA”: name, job description, constraints)
3. User file (who it serves: goals, preferences, context about the user/team)

Pro tip: generate these files with AI by prompting it to interview you, then output a near-complete template.

E = Equip it (context + tools)

• Core principle: “garbage context in, garbage context out.”
• Uses a “context window” metaphor including:
  • Identity
  • Playbooks (procedures)
  • Tools/access
  • Loops/schedules
  • Memory/storage

Two ways to capture processes/playbooks:

• Camcorder method: record yourself doing the task; AI converts it into a playbook.
• Recommended method: reverse engineer from source
  • Connect to real systems (e.g., Gmail)
  • Have AI analyze historical examples
  • Produce procedures/style guides

Convert subprocesses into system prompts / structured instructions (e.g., sort, draft, escalate, report).

N = Narrow the scope

• Avoid “mega agents” that do too much (risk: confusion/context overload and “context rot”).
• Use sub-agents specialized per function (e.g., code-writing vs code-review).
• Use an orchestration/manager agent (e.g., “Kai”) to coordinate sub-agents and consolidate outputs.

T = Trust (autonomy safely in stages)

• Don’t grant full autonomy immediately (“don’t hand over the keys on day one”).
• Stage rollout:
  • test drafts/sorting → allow more actions → allow limited sending/forwarding → eventually full running on a schedule
• Set guardrails via identity files (what it can/can’t do).
• Approve everything at first, then gradually loosen control.
• Use recurring schedules (“heartbeat”) so it runs autonomously (example: inbox checks every 15 minutes).

Model selection & cost control (Anthropic example)

Different models fit different workloads:

• Haiku: cheaper, simple/high-volume tasks (sorting, labeling, quick drafts)
• Sonnet: day-to-day work, research, writing most code
• Opus: higher-level reasoning/complex agent management
• Fable: new orchestrator/consultant style; strong for long-running/complex tasks; most expensive

Example: an inbox agent running every 15 minutes might use Sonnet, while complex build steps might use Opus/Fable.

Cost anecdote: refactor task could cost $150 with Opus, but reportedly cost $1.50 using Haiku.

---

Guides/tutorials explicitly discussed

Step-by-step tutorial to build a first AI agent

Includes:

• Compare chatbot vs agent
• Apply Rule of R
• Follow AGENT steps:
  • Outcome → Identity → Equip → Narrow → Trust
• Build an inbox agent example using:
  • outcome prompt
  • Definition of Done
  • soul/identity/user files
  • context/tool access (Gmail connector)
  • playbooks via reverse engineering
  • sub-agents + manager agent
  • staged autonomy + guardrails

Practical workflow for process capture

• Either:
  • record yourself (camcorder), or
  • derive playbooks from historical data (reverse engineer)

---

Main speakers/sources (attribution from subtitles)

• Primary speaker: the video narrator/host (no name given in subtitles)
• Mentioned example/orchestrator persona: “Kai”
• Mentioned external models: Anthropic models (Haiku, Sonnet, Opus, Fable)