| Creator | AI Master |
| Title | AI Agents Explained: How to Create and Use AI Agents in 2026 |
| Source | youtu.be/4TvH-OZhwxI |
| Transcript Date | 2026-06-07 |
| Playlist | AI Agents Full Course 2026 |
Most people paying for an AI subscription are using it as a chatbot when the same model, wired differently, can operate as a full agent -- opening browsers, running files, chaining tasks, and completing complex work autonomously. The difference between a chatbot and an agent is not the AI model itself but what is bolted around it: tools, memory, goals, and a loop of observe-think-act. This video tours four agent platforms worth using in 2026 -- Claude Code, OpenAI Codex, OpenClaw, and Google Antigravity -- and explains where each one wins. The core skill introduced is the Prompt Contract, a four-section structure (Goal, Constraints, Format, Failure) that turns vague instructions into a brief the agent can actually deliver against. Pairing prompt contracts with a persistent memory file means the agent builds its own operating rules over time, compounding reliability with every session.
Quotable moments are auto-generated from the transcript. Speaker attribution and quote accuracy should be verified against the original source before republishing or sharing.
An AI agent is not a smarter chatbot -- it is the same language model with four things added: tools (the hands to act on files, browsers, and APIs), memory (a file the agent reads at session start so it arrives with context), goals (specific outcomes with a clear definition of done), and a loop (the observe-think-act cycle that runs until the goal is reached). Remove any one of these and you have something weaker than an agent.
Every agent on every platform runs the same three-step engine repeatedly until the task is complete. Observe: the agent checks the current state of the world -- what files exist, what a page shows, what the last command returned. Think: it decides what to do next based on what is actually true right now. Act: it uses one of its tools to change something. The loop repeats, checking against the goal each time.
A chatbot prompt is a description of what you want. An agent prompt is a contract -- a structured brief the agent delivers against. The four required sections are Goal (the outcome with a finish line, not just an action), Constraints (explicit guardrails on what the agent cannot do), Format (the exact shape of the expected deliverable), and Failure (instructions for what to do when stuck). All four must be present for an agent to run reliably.
Agent platforms read a plain text file at the start of every session before touching any task. Claude Code reads claude.md; OpenClaw reads agents.md; Antigravity has its own equivalent. Whatever is in that file becomes a permanent rule the agent follows in every subsequent session. Dropping a memory file in the project root gives the agent a long-term operating manual that survives across conversations.
"Build a landing page" is an action. "Build a single-page site that pushes visitors to one email sign-up above the fold, ready for local review before deploying" is an outcome. The goal section of a prompt contract must include a clear finish line -- a way for the agent to know it is done. Without a finish line, the agent invents one, and the inventor is rarely right.
Constraints are everything the agent is not allowed to do. Every time an agent does something technically within the goal but against the spirit of the task -- installs an unwanted dependency, touches a file outside scope, pulls copy from a competitor -- that becomes a permanent constraint in the next prompt. The constraint list only grows. It is scar tissue, not overhead.
Most prompts skip the Failure section, and that omission is the most expensive mistake in agentic work. Without guidance on what to do when stuck, an agent defaults to looping -- trying repeatedly, burning tokens, until something works or the user kills it. One sentence fixes this: instruct the agent to stop and ask one consolidated question, or to stop and report what it tried. Define uncertainty handling before the agent starts.
Beyond a static memory file, you can instruct the agent to update its own memory file at the end of each task. The rule: if you corrected me or I hit a bug from a wrong assumption, append a new rule to the learned rules section at the bottom of this file. Session one has one rule. Session twenty has twenty. The agent builds its own operating manual over time without requiring manual maintenance from the user.
Claude Code shows its reasoning step by step in real time, allowing the user to steer, pause, redirect, or hand the agent new context mid-task. This makes it the strongest platform for complex orchestration, chaining agents together, or anything where you want a thinking partner rather than a system that fires and runs. Despite its name, it handles non-code tasks equally well -- file organization, PDF parsing, batch renaming, media production workflows.
Codex is bundled with ChatGPT Plus, Pro, Business, and Enterprise plans. If you already pay for ChatGPT, the agent is already covered under the same login with no additional subscription. It also offers a cloud mode that lets you hand off long-running tasks to a sandbox and walk away, returning to a finished branch. The VS Code and Cursor extensions embed it as a sidebar with a built-in diff view for reviewing every proposed change before it lands.
OpenClaw is open-source, self-hosted on your own machine, and uniquely lives inside messaging apps rather than a dedicated interface. You text the bot from anywhere; it does the work on your computer and texts you back. Its skill marketplace connects to Apple Notes, Notion, Things 3, Google Docs, PowerPoint, and 20+ other apps. It is built for life automation -- email triage, document creation, project management, knowledge organization -- not primarily for code.
Antigravity is a heavily modified VS Code fork running Gemini as the agent. Its strength is multimodal perception -- the agent can actually see what it is doing, read screenshots, check layouts, compare design variations, and generate images. For front-end work, UI mock-ups, landing pages, and anything that requires the agent to visually evaluate its own output, Gemini's multimodal stack is ahead of the other platforms. Currently free in public preview for individuals.
Implementation steps are auto-generated from the transcript content and are provided for informational purposes only. They do not constitute professional advice of any kind. Always consult a qualified professional before acting on any information presented here.
Use the platform routing rule from the video: if your work is primarily words, reasoning, or complex task chains, install Claude Code (paid Anthropic plan required, $17-20/month). If you already pay for ChatGPT Plus, open chat.openai.com and download Codex -- it is already included in your subscription with no extra steps. If you want an agent that works through Telegram or iMessage and handles life tasks, go to claw.bot, copy the install command, and paste it into your terminal. If your work is visual or front-end, search "Google Antigravity download" and install the free desktop app. Commit to one platform to start. Switching later is easy; spreading thin now means you go deep on none of them.
The common mistake is testing an agent on something trivial -- writing a poem, summarizing a sentence -- and concluding it is marginally better than a chatbot. Instead, identify a task that currently takes you 30 to 90 minutes and involves multiple steps: reorganizing a folder of files by date and type, pulling all transactions from a set of PDFs into a spreadsheet, building a simple single-page site, or drafting and filing five email responses. The folder cleanup demo from the video -- 80-plus files sorted, renamed, and catalogued into a spreadsheet -- is a good benchmark. If the agent completes a task at that scale correctly, you understand what you are working with. If it goes sideways, the next step explains why.
Before hitting enter on any non-trivial agent task, write four labeled sections in plain text. Goal: describe the outcome with a clear finish line -- what does "done" look like, not just what action to take. Constraints: list everything the agent is not allowed to do (don't install new dependencies, don't touch files outside this folder, don't deploy anywhere, don't pull from external sources). Format: specify the exact shape of the deliverable -- one index.html with inline CSS, or a folder containing three named files, or a single spreadsheet with columns in this order. Failure: write one sentence telling the agent what to do when it gets stuck -- "if information you need is missing, stop and ask one consolidated question before continuing." This will feel like overhead the first time. By the third run it becomes the only way you brief an agent.
After your first agent session, create the platform memory file in the root of your project folder. For Claude Code, this is claude.md. For OpenClaw, it is agents.md. For Antigravity, check the platform docs for the equivalent filename. The file is plain text. Start with two to three rules you already know apply to your work -- your tone preferences, file naming conventions, things the agent should never do regardless of the task. Ask the agent itself to create the file: "Create a claude.md in the root of this project with these three rules." It will write and save the file. Every subsequent session, the agent reads it before doing anything else.
Once the memory file exists, add one instruction to it: "If I corrected you during this session, or if you made a wrong assumption that caused a problem, append a new rule to the Learned Rules section at the bottom of this file before finishing." This turns every mistake into permanent institutional memory. The agent does not need you to manage the file manually -- it updates itself. After five or six sessions, you will have a memory file with 15 to 20 rules that reflects the actual working patterns of your projects, written in the agent's own language, derived from real errors. The compounding effect on reliability is significant.
Every time an agent does something you did not want -- installs a framework you hate, adds emojis to copy, deploys something before you reviewed it, touches a file outside scope -- write that constraint down immediately. Keep a running plain-text list somewhere accessible, organized by category: file behavior, output format, external dependencies, tone and style, deployment rules. Before writing any new prompt contract, scan this list and copy the relevant constraints into the Constraints section. This is what the video calls scar tissue -- it only grows, and over time it becomes the most valuable part of your agent workflow, reducing wasted token runs and rework significantly.
In Claude Code, there is a setting called Bypass Permissions. By default, the agent asks before each significant action -- writing a file, running a command, opening a browser tab. Bypass Permissions lets it act independently through a full task without interrupting for approval at each step. Enable this when you have a well-written prompt contract in place and a clear, bounded task scope. Leave it off when exploring a new type of task or when the agent is working in a folder that contains anything you cannot afford to have modified unexpectedly. The setting is not dangerous in itself -- it is a workflow accelerator that pairs with the constraint guardrails you have already written.
If you are on OpenAI Codex, the cloud sandbox mode lets you hand off a long-running task -- building a full feature, processing a large dataset, running a research job -- and close your laptop. The agent works in an isolated cloud environment and delivers a finished branch you can review when you come back. This is particularly useful for tasks that would otherwise require your machine to stay on and active for 30 to 90 minutes. The tradeoff is that the cloud environment has no access to local files, so tasks must be fully self-contained or use files you have committed to the project. Plan your task scope accordingly before queuing a cloud run.
If the life automation use case fits your workflow -- capturing ideas on the go, triaging email from a phone, managing to-do items through iMessage -- install OpenClaw as a parallel tool alongside whichever coding or reasoning agent you chose. The install is a single terminal command from claw.bot. During onboarding, choose Telegram as your messenger (it is the cleanest interface for a dedicated bot), paste your Telegram bot token, and select three to five skill integrations from the marketplace that match what you actually use: Apple Notes, Notion, Things 3, or Google Docs. OpenClaw works best when you treat it as the ambient layer -- the agent you message informally throughout the day -- while your primary coding agent handles structured, scoped work sessions.
Once you are comfortable running individual tasks with prompt contracts and memory files, the next level is chaining agents together. Claude Code is the strongest platform for this because you can watch the reasoning step by step and steer mid-flight. A chained workflow looks like this: Agent A produces a research summary and hands it off as a file. Agent B reads that file and writes a structured brief. Agent C takes the brief and builds a deliverable. You sit at the top, reviewing outputs between handoffs rather than doing the work. This is the architecture that makes a week of work completable before lunch -- not a single faster task, but a pipeline that runs while you do other things.
Every tool, platform, and service mentioned in this video, with direct links. Descriptions reflect how each was characterized in the transcript.
Anthropic's official agent. Runs as a desktop app on Mac, Windows, and Windows ARM 64. Best for interpretable step-by-step reasoning, complex task orchestration, and chaining agents together. Requires a paid Anthropic plan ($17/month annual or $20/month monthly). Despite the name, handles non-code tasks equally well -- file organization, PDF parsing, batch renaming, media workflows.
claude.ai/downloadOpenAI's official agent, bundled with ChatGPT Plus, Pro, Business, and Enterprise plans. Lowest-friction entry point for anyone already paying for ChatGPT -- same account, no new subscription. Includes a cloud sandbox mode for long-running tasks and VS Code / Cursor sidebar extensions with a built-in diff view. Available on Mac, Windows, and Linux.
openai.com/codexOpen-source agent that self-hosts on your machine and lives inside messaging apps -- Telegram, WhatsApp, iMessage, Discord, Signal, Slack, Microsoft Teams, and 20+ others. Built by Peter Steinberger (founder of PSPDFKit). Installs with a single terminal command. Best for life automation: email triage, document creation, reminders, project management, knowledge organization. Skill marketplace connects to Apple Notes, Notion, Things 3, Google Docs, PowerPoint, and more.
claw.botGoogle's agent platform built on Gemini. A heavily modified VS Code fork with a dedicated agent panel on the right side. Currently in public preview, free for individuals with generous rate limits on Gemini 3 Pro -- no card required. Best platform for visual and front-end work: UI mock-ups, design iteration, landing pages, anything requiring the agent to see and evaluate its own output. Supports Mac (Apple Silicon and Intel), Windows, and Linux.
Search "Google Antigravity download"All-in-one email, SMS, automation, and CRM platform mentioned as the video sponsor. Includes Aura AI for generating subject lines, preview text, and email body in the sender's tone. Pricing scales by sends rather than contact count. Free plan includes 300 sends per day. Promo code IAMAIMASTER50 offers 50% off Starter and Standard plans for the first 3 months (new paying customers only).
brevo.comThe creator's own platform: a specialized agent pipeline for content production. Three agents (Producer, Script Writer, Designer) that communicate with each other automatically across YouTube, Instagram, TikTok, LinkedIn, newsletters, and podcasts. Positioned as a done-for-you content engine rather than a general-purpose agent stack. The video is part of the AI Agents Full Course 2026 playlist on the AI Master channel.
aimaster.meThe web chat interface for Claude (claude.ai) and the API key management console (console.anthropic.com). Required for generating an API key if using OpenClaw with Anthropic's Claude as the AI provider. The Pro plan at $17-20/month covers both Claude.ai chat and Claude Code desktop.
claude.ai • console.anthropic.comAPI key management for OpenAI, required if using OpenClaw with GPT as the AI provider. ChatGPT Plus ($20/month) also covers the Codex agent desktop app at no additional cost.
platform.openai.comBoth editors are mentioned as hosts for the OpenAI Codex IDE extension, which embeds the agent as a sidebar with a built-in diff view for reviewing proposed file changes before they land. Antigravity is also built as a modified VS Code fork.
code.visualstudio.com • cursor.comRecommended as the primary messenger for OpenClaw integration. Described as clean, easy to dedicate to a single bot, and the most popular OpenClaw messenger choice. You connect it by creating a Telegram bot and pasting the bot token during the OpenClaw onboarding wizard.
telegram.orgThis transcript was auto-generated and may contain errors in speaker attribution, transcription accuracy, or formatting. Long transcripts may be truncated due to processing limits. Confirm accuracy and completeness against the original source before referencing or republishing.
Same Claude, same 20 bucks a month. Two completely different tools -- a chatbot and an AI agent. One answers questions inside a chat window, the other opens your browser, runs 10 tasks at once, and finishes a week of work before lunch. Most people are paying for the second one and using it like the first. And that's the most expensive mistake in AI right now.
Here's a folder on my desktop -- 80-something files. PDFs, screenshots, receipts, invoices, contracts, random downloads from the last 3 months. Total mess. One command, plain English. The agent reads every file, sorts everything into categorized folders, renames by date and vendor, and builds one spreadsheet with every expense for tax season. A few minutes later: eight clean folders, every file renamed to the same format, and one spreadsheet with every expense from the last 3 months -- date, vendor, amount, category -- ready to hand to an accountant. A chatbot can tell you how to do this. An agent just does it.
Quick foundation, because if you skip this, nothing else in the video makes sense. A chatbot and an agent can run on the exact same model. The brain is identical. The difference is what's wired around the brain. Picture a world-class chef sitting in an empty room -- same training, same palate, same instincts as the chef running a Michelin kitchen across town. But with no stove, no ingredients, and no order ticket telling them what to make, they can't actually cook a thing. The skill didn't change. Everything around the skill did.
A chatbot is the brain alone. You type, it answers. Conversation ends. It can't open a file, run a command, browse a website, or remember what you taught it last week. It lives inside the chat window. An agent is the same brain with four things bolted on: the LLM (the reasoning engine), tools (terminal, browser, file system, APIs -- the hands), memory (files the agent reads at the start of every session -- the notebook), and goals (not vague wishes, but specific outcomes with a clear definition of done -- the destination). Tie those four together with a loop and you have an agent.
The loop has three steps. Observe: the agent looks at the current state of the world -- what files exist, what the page shows, what the last command returned. Think: it decides what to do next based on what's actually true right now. Act: it uses one of its tools to change something. Then it repeats. Observe, think, act -- checking against the goal until done. That's the entire engine. Every agent on every platform runs this same loop.
Claude Code is Anthropic's official agent. Runs as a desktop app on Mac, Windows, or Windows ARM 64. Free Claude.ai does not include Claude Code -- you need a paid Anthropic plan: the Pro plan at $17/month annual, or $20 if you pay monthly. Same subscription covers chat at Claude.ai and Claude Code. To install: search "Claude Code desktop download," download for your OS, drag into applications, sign in. First run shows a chat page -- click the code button, choose a folder, and you're ready.
One setting to know: Bypass Permissions. It lets the agent act independently without asking before each step. The interface shows a message box at the bottom, a thinking panel with real-time reasoning, and tool calls as it edits files or runs commands. You can queue follow-up messages that the agent picks up the moment the current task finishes. Claude Code is not just a coding tool -- the name throws people off. The folder cleanup demo at the start? That was Claude Code. Treat it as a general-purpose agent that happens to be great at code.
Where Claude Code wins: interpretable reasoning. You can watch the model think step by step and steer it mid-flight -- pause it, redirect it, hand it new context. That makes it the strongest of the four when orchestrating something complex or chaining agents together. Anything where you want a thinking partner, not a missile -- Claude Code.
Codex is OpenAI's official agent, and the easiest way in for anyone already in ChatGPT. It's bundled with ChatGPT Plus, Pro, Business, and Enterprise plans -- if you already pay $20/month for ChatGPT Plus, Codex is already covered. Same login, no extra subscription. Download from openai.com/codex, drag into Applications, open it. First run: create a project folder, open inside it, type your task.
Codex has one trick the others don't: a cloud version at chat.openai.com. Hand off a long-running task to a sandbox in the cloud, walk away, come back to a finished branch. Useful when you don't want to keep your laptop running. The IDE extension drops it straight into VS Code or Cursor as a sidebar with a built-in diff view -- every proposed change visible file by file before it lands.
OpenClaw is open source, self-hosted on your own machine, built by Peter Steinberger (founder of PSPDFKit) as the personal AI agent he wanted for himself. Over 100,000 GitHub stars in its first week. The killer feature: it lives inside your messengers -- Telegram, WhatsApp, iMessage, Discord, Signal, Slack, Microsoft Teams, 20+ apps. Text the bot from a coffee shop, the agent does the work on your computer at home, and texts you back when done.
Installation is one line of code. Go to claw.bot, scroll to quick start, copy the install command. Open terminal. Paste the command, hit enter. Done. That single line installs OpenClaw and kicks off an onboarding wizard covering: AI provider (Anthropic for Claude, OpenAI for GPT, MiniMax for budget), API key, default model, skills (3 to 5 integrations from the marketplace), and messenger (Telegram is the popular pick -- paste your bot token to connect).
Where OpenClaw wins: life automation -- not code, real-life stuff. Email triage, reminders, document creation, project management, knowledge organization. Text it a video idea, it files it. Text it a tweet draft, it stores it. Text it a research note, it categorizes it. With full computer control and skill integrations, basically anything a human can do on a computer, OpenClaw can do.
Antigravity is Google's agent platform built on Gemini -- a desktop app, specifically a heavily modified VS Code fork. Mac, Windows, Linux all supported. Currently in public preview, free for individuals with generous rate limits on Gemini 3 Pro, no card required. Install: search "Google Antigravity download," check your chip (M-something means Apple Silicon, Intel means Intel), download the right build, drag into Applications, sign in with Google.
First run layout: code editor in the middle, file tree on the left, agent panel on the right where you talk to Gemini. Same general feel as Claude Code and Codex, slightly different flavor. You can queue follow-up messages the same way. Where Antigravity wins: anything visual. Best agent for front-end work, UI mock-ups, design iteration, landing pages, and anything involving images or video. Gemini's multimodal stack is ahead of the others when the agent needs to actually see what it's doing.
Now let's fix the single thing that breaks the most agent runs across all platforms -- the prompt itself. A chatbot prompt is a description of what you want. An agent prompt is a contract, a brief the agent has to deliver against. Hand a vague prompt to an agent and you've just lit money on fire. The agent has tools, a loop, real autonomy. It'll spin up, start scaffolding files, install whatever framework it feels like, push a dark mode hero section you didn't ask for, and hand you something you didn't want -- at real token cost.
A real agent prompt -- a Prompt Contract -- has four sections: Goal, Constraints, Format, Failure. Goal: the outcome, not the action. "Build a landing page" is an action. "Build a single-page landing site optimized to convert visitors into email sign-ups above the fold, ready for local review before deploying" is an outcome. The goal must include a clear finish line. Without one, the agent invents one.
Constraints: everything the agent is not allowed to do. Don't install new dependencies without asking. Don't touch files outside the landing folder. No external CDN scripts. Don't deploy anywhere. Constraints prevent the agent from doing something technically inside the goal but completely against the spirit of it. Every time an agent does something stupid you didn't anticipate, that becomes a permanent constraint in your next prompt. Your constraint list is your scar tissue -- it only grows.
Format: the exact shape of the output. Don't just describe the work -- describe the deliverable. "Output a single index.html file with inline CSS, no JavaScript frameworks, mobile responsive, plus a brief .md that lists every section in order with the headline copy used." The format section is where you reach into the agent's head and decide the shape of the deliverable before it starts. If you can't describe the format in one sentence, you don't actually know what you want yet. You should not have hit enter.
Failure: what to do when stuck. Almost nobody writes this section, and it saves the most tokens. Without instructions, agents default to the worst option -- they keep trying, looping, burning tokens until something works or you kill it. One sentence: "If you're missing information you need, stop and ask before continuing." Or: "If a tool call fails twice in a row, stop and report what you tried." Define how the agent handles uncertainty -- or it will define it for you, expensively.
Here's what breaks the most experienced users: they run a task, the agent does something wrong, they correct it, they run it again, same mistake. The agent isn't broken -- you just never told it to remember. Every serious platform has a memory file: Claude Code reads claude.md, OpenClaw reads agents.md, Antigravity has its own version. Drop that file in the root of your project and whatever's in it becomes a rule the agent follows forever.
Real example: every single run, the agent was slipping emojis into customer-facing copy -- button labels, error states, confirmation messages. Strip them out, next session they came back. One instruction to the agent: "Create a claude.md in the root of this project and add one rule -- never use emojis in customer-facing copy unless I explicitly ask. This is a B2B product." It created the file, added the rule. That issue never appeared again in any project.
Now layer on the real trick -- make the file self-modifying. Tell the agent: "If I corrected you or you hit a bug from a wrong assumption, append a new rule to the learned rules section at the bottom of this file." The agent now updates its own memory. Session 1: one rule. Session 5: twenty rules. Session 20: the agent rarely makes a preference mistake because it's been writing its own scar tissue the whole time.
Three things to remember. First: the Prompt Contract -- Goal, Constraints, Format, Failure. That's what turns an agent from an expensive chatbot into something that ships. Second: memory. One memory file in the root of your project -- claude.md, agents.md, whatever your platform uses -- and the agent stops making the same mistakes session after session. Third: the four platforms each win at something different. Pick the one that fits your work and go deep. Stop reading about AI agents. Start running them.
The AI prompt on this page is auto-generated from the transcript content and is intended to support further exploration of the topics, concepts, and conclusions discussed. It is provided for informational purposes only. The user is solely responsible for all outcomes resulting from its use.
You are an expert AI agent implementation coach specializing in the practical transition from chatbot workflows to autonomous agent workflows. CONTEXT: This session is based on a video by AI Master covering how AI agents actually work in 2026 and how to use them effectively. The core framework is built around four ideas: (1) an agent is a language model wired with tools, memory, goals, and a loop -- not a smarter chatbot; (2) the Prompt Contract is the only reliable way to brief an agent (four required sections: Goal, Constraints, Format, Failure); (3) persistent memory files teach an agent once so you never repeat yourself; and (4) four platforms each win at a different job -- Claude Code for complex reasoning and orchestration, OpenAI Codex for lowest-friction entry, OpenClaw for life automation through messaging apps, and Google Antigravity for visual and front-end work. The observe-think-act loop is the engine underneath every agent platform. The agent checks the current state of the world, decides what to do next based on what is actually true right now, acts using one of its tools, and repeats until the goal is reached. Understanding this loop explains why vague prompts fail -- the agent needs a goal with a finish line to know when to stop. A Prompt Contract is the structural shift that separates chatbot users from agent operators. Goal describes the outcome, not the action, and must include a clear definition of done. Constraints list everything the agent is not permitted to do. Format specifies the exact shape of the deliverable before the agent starts. Failure defines what the agent should do when it gets stuck -- without this section, agents loop and burn tokens by default. All four sections are required. Memory files (claude.md, agents.md, or the platform equivalent) are plain text files read at the start of every session. They make every correction permanent. Making them self-modifying -- instructing the agent to append new rules after each correction -- turns every mistake into institutional memory that compounds across sessions. KEY PRINCIPLES: - The brain (LLM) is the same in a chatbot and an agent. What differs is what is wired around it. - Every agent runs the same observe-think-act loop on every platform. - A Prompt Contract replaces a description with a deliverable brief. All four sections are non-optional. - Constraints are scar tissue -- they only grow, and they are the most protective part of any prompt. - The Failure instruction saves the most tokens of any section. Never skip it. - Memory files give the agent a long-term operating manual that survives across sessions. - Self-modifying memory means the agent builds its own rules from its own mistakes. - Platform routing: Claude Code for reasoning, Codex for friction-free entry, OpenClaw for life automation, Antigravity for visual work. WHAT THIS IS NOT: This is not about prompt engineering tricks for chatbots, making GPT write better poems, or optimizing a single response. It is specifically about the structural change in how you brief, deploy, and maintain an autonomous agent that takes actions in the world. The difference between a chatbot session and an agent run is the difference between advice and execution. This framework is about execution. HOW TO USE THIS CHAT: 1. Platform selection -- Tell me what kind of work you need to hand off and I will recommend the right agent platform with specific reasons, not a generic comparison. 2. Prompt Contract writing -- Describe a task and I will help you write a full four-section Prompt Contract (Goal, Constraints, Format, Failure) before you run it. I will push back if any section is vague or missing a finish line. 3. Memory file setup -- Tell me your platform and your working context and I will draft a starter memory file (claude.md or agents.md) with rules drawn from your actual workflow, plus the self-modifying instruction. 4. Constraint library building -- Describe a bad agent run and I will help you extract the constraints that would have prevented it, in language ready to paste into your next prompt contract. 5. Loop debugging -- If an agent went off the rails, walk me through what happened and I will diagnose which part of the loop broke down and which section of the prompt contract was missing or weak. 6. Workflow chaining -- If you are ready to move beyond single tasks, describe your end goal and I will help you design a chained agent workflow with handoff points and review gates. TONE: Direct, operational, and specific. No motivational framing. Help me build things that work, not feel good about AI. If my prompt contract is weak, tell me which section and why. If my task scope is too vague, say so before we write anything. To begin: what kind of work are you currently doing manually that takes 30 to 90 minutes and involves multiple steps or files? Describe it in plain terms and we will build the Prompt Contract for it together.