AI agent basics course: understand it properly in 2 hours so you don’t get fooled

The tenth course in MONA's free AI course series, and the “short but solid” one of the whole series: intro to AI agents, built on a 2-hour syllabus of pure foundational theory plus advanced prompting techniques, not tied to any one platform. If the earlier courses taught you use individual tools (Claude Code, Antigravity, Cowork, n8n), this one teaches the common backbone underneath all of them: how an agent really operates, why the same question gets a different answer each time, and the set of techniques that make a machine that “guesses with probability” work like a disciplined team. After this course, whenever anyone pitches you an “AI agent solution,” you'll be able to tell the real thing from the show on your own: that alone is worth the 2 hours. It's also the course we recommend reading before you set an AI budget for your company, because the last part covers a cost problem few people teach.

Part 1: What an AI agent is: the three-beat loop and the forgotten “definition of done”

A chatbot is a language model that answers questions. Agent = model + tools + memory + a loop that pursues a goal to the end. That loop, on any platform, has three beats:

1. Observe: read the full context: files, results of earlier tool calls, the rules file (CLAUDE.md, GEMINI.md, AGENTS.md), and image or audio data if there is any.
2. Reason: from the context and the goal, work out the next step. Decent platforms let you click to view this “line of thought”: it is the window through which a supervisor can steer.
3. Act: call tools, edit files, run commands. The result of the action flows back into the Observe beat: the loop keeps turning and the context keeps swelling.

The loop stops when it reaches the “definition of done”: a set of criteria telling the machine what finished means. And here is the home-grown mistake of agent users: handing off work without defining done. “Make me a really beautiful website” is a brief with no finish line: the machine runs forever or stops at random. “A one-page intro site with these 4 blocks, smooth on mobile, under 500 lines of code” is a brief with a finish line: the machine knows when it may rest. You'll notice that every technique from the earlier courses (defining “done” in the DOE instruction, the stop rules in Cowork) is a variation on this single principle.

One metaphor from the syllabus is worth retelling because it sets expectations right: a bare language model is like a brilliant person from twenty thousand years ago, standing in a field holding a spear: plenty of intelligence but no home, no fire, no tools, so they can do very little. An agent is that same person handed a full toolkit and a job to see through. Meaning: when AI “talks well but gets nothing done,” the problem is mostly not the brain, it's that nobody has given it proper tools and a destination: the two things this course teaches you to supply.

Part 2: The three big platforms, and a comparison table that tells it straight

Three names dominate agents right now: Claude Code (Anthropic), Codex (OpenAI), Antigravity with Gemini (Google). The syllabus compares them in the spirit we like: the gap between top models is only a few percent and the lead changes with every training round, so don't worship any of them; what's worth remembering is each one's personality :

• Claude: the most readable line of thought and the easiest to intervene in mid-run → suited to being the orchestrating conductor and to tasks that need close supervision. In exchange it is slower (unless you switch on fast mode, which costs more) and its interface design loses to Gemini.
• Gemini: the champion of interface design and understanding native video (watching the actual video, not reading subtitles): two things the other two still struggle with. In exchange its line of thought is hard to read and its form rises and falls from day to day.
• Codex (GPT): strongest at backend and math, suited to the style of handoff where “done is defined by a test suite, then let it run on its own.”

The syllabus's practical conclusion: picking one and sticking with it is fine; but the strongest lineup is to use all three according to their personalities: the subject of Part 5. On price: all three sit around $17-20 a month for the entry plan. If you're following this course series, a Claude Pro plan already covers all three Claude courses, and adding free Antigravity completes the syllabus.

Part 3: The self-evolving rules file: teach the machine once, it remembers forever

You're already familiar with the rules file (CLAUDE.md, GEMINI.md, AGENTS.md: the same idea, a different name from each vendor) from the earlier courses. This course adds a very valuable layer: make the agent write its own rules. Put a clause in the rules file: whenever the user corrects it (rejects an approach, criticizes a choice, catches an error the machine guessed wrong), the agent must add a new rule line itself at the end of the file, in the form “topic: always/never do X, because Y.” An example from the syllabus: the machine keeps building dark-background sites, the user types “drop the dark background habit,” and the machine writes the rule “never build dark-background apps,” and doesn't repeat it from the next session on. The first time you use it, the machine gets ten things wrong; by the fifth time, almost none: the machine's errors shrink over time as you use it, just like a well-mentored employee: and the mentoring is just doing your normal work and letting it learn from experience.

Alongside it comes a layered structure worth copying: a global rules file (applies to every project: tone, general habits), a per-project rules file (specific to that job), then packaged skills, and only then the prompt for each run. The higher the layer, the fewer the words but the longer they live: putting your words in the right layer is the secret to using few tokens while the machine still knows its lessons.

Part 4: The task contract and reverse prompting: two techniques against “vague handoffs”

Two sibling techniques treat the same disease: vague briefs, the top culprit behind people's disappointment with agents.

• Prompt contract: before doing any non-trivial task, the agent must draft a four-part “contract” for the user to approve: goal, constraints, output format, and conditions that count as failure. The last part is the genius one few people think of: spelling out “what counts as failed” (looks like a mass-produced free template, breaks on mobile, over 500 lines of code) blocks in advance exactly the paths the machine tends to slip down.
• Reverse prompting: tell the agent: after receiving the job, ask 5 clarifying questions back before touching anything: what the main goal is, which implicit assumptions need confirming, which direction the aesthetic should go. The user answers in 2 minutes and the odds of “nailing it in one go” jump. You met this trick in the Claude course (“before you start, ask me whatever is missing”): this is its full version, and the two techniques chain together: reverse prompting first, then pour the answers into the contract.

Part 5: A multi-model team: the router and the MCP orchestra

The heaviest piece of the technique section: have one model act as conductor, directing other models through the MCP protocol. The architecture: Claude sits in the middle, takes the job, breaks it down, then assigns each part to the model whose personality fits: interface to Gemini, backend and testing to Codex, anything involving video to Gemini (it understands native video), and if fresh web data is needed, call a search service as well; then the conductor gathers the work, cross-checks it and patches what doesn't line up. The double benefit: it is both parallelized (branches run at the same time) and each job is done by the model best at that job, and the conductor grades the work with eyes not “polluted” by the context of the branches. The price you need to know: going through the API directly loses the “subsidy” of the monthly plan (the fixed plans from these vendors are worth many times the subscription price if you converted to retail API pricing), so multi-model lineups are only worth switching on for jobs that deserve it.

Parallel lineups also have a very easy-to-picture “muscle” variant: cloning browsers. The real problem in the syllabus: filling in a contact form on 1,000 partner websites, one agent per form opening its own browser, finding the form, filling it and submitting it. One agent working sequentially takes over 30 hours; send 100 agents in parallel, each with its own browser window, reporting to one shared file the conductor checks off: 40 minutes. The same principle applies to price lookups, checking stock across many sites, and reconciling contact lists: wherever the same job repeats identically across many targets, parallelizing pays off. With an ethical note we sign with both hands: this power is not a license to scrape other people's data; use it within each platform's terms.

A very down-to-earth spin-off application: from video to action. The machine can't watch a tutorial video by itself? Let Gemini watch for it: it breaks the video into a step list detailed down to the second and hands it back to Claude, which takes that list and actually does it on the machine. The syllabus demos this with a 21-minute tutorial video: the machine watches, extracts the steps, then rebuilds the entire process in the real tool until it runs. The vast library of tutorial videos online is, from now on, a library of processes machines can learn directly.

Part 6: The power of a disciplined crowd: consensus, debate, and the three-role review loop

This part answers the most fundamental question: the machine answers differently each time (statistical randomness), so how do you reach a decision you can trust? The answer: don't ask once: organize a disciplined crowd, in three formations:

• Statistical consensus: send 10 agents in parallel on the same strategy question, each with a slightly different lens (conservative, tight budget, only trust what can be measured, end-user view…). Sort the results into three baskets: consensus (most agree: high confidence, doable), disagreement (needs more thought), and outliers (only 1 in 10 says it: either a flash of insight or made up: the decision-maker judges). The syllabus's real cost for a cluster of 10 agents analyzing strategy: about $3-4: cheaper than any meeting ever held. The real case in the syllabus makes it stick: a content channel strong on two platforms but weak on a third; ask 10 agents “why and what to do”: the consensus basket points out the content was carried over in the old platform's format (the opening must be redone for the new platform's habits), and the outlier basket has one agent suggesting a paid-ad route nobody had thought of. The decision-maker is still a human: but never before has a decision-maker been handed a map from so many angles for the price of a cup of coffee.
• Debate room: give each agent a personality (the systems thinker, the pragmatist, the edge-case hunter, the user's advocate, the contrarian) then let them debate in a circle in a shared file. The opinions come out much “sharper” than in silent parallel runs, and the debate transcript is valuable material for the decision-maker.
• Three-role review loop: maker → reviewer (clean context, sees only the product, not the process: immune to the “sunk effort” bias that makes machines grade themselves high) → fixer. In a real demo, the clean-context review caught 22 bugs in a codebase the machine itself had confidently called fine. This is the full version of the “review in a clean session” ritual you've been learning throughout the series.

Part 7: Machine memory and your wallet: the iceberg, context compression, and the 60-30-10 rule

Two things that sound technical but are really about money:

• Context is an expensive resource: a model's memory window runs from 200 thousand to 1 million tokens, but quality drops as the context fills up, and everything you load in is billed: the rules file, skills, chat history. The standard strategy is the iceberg: the visible part that always comes along (rules file, current task) kept very lean at around 20-30%; the submerged part (the whole codebase, history, documents) the machine dives down to fetch when needed through read and search tools. All platforms have a command to inspect context (like /context) and a mechanism to compress automatically when nearly full: compressing loses detail, so long jobs need a “handover note” as you've learned.
• The 60-30-10 rule: don't make the most expensive model do everything. A router splits the work: about 60% of the volume (muscle work: classifying, extracting data) goes to the cheapest model, 30% (medium work: summarizing, drafting) to a mid-tier model, 10% (the hardest work and the routing itself) to the top model. The syllabus's illustrative math: the same block of work costs $500 on top-tier models only, and $200 when tiered: 60% saved with no loss of quality, because easy work never needed a big brain. A real case goes with it: a daily scraping and customer care pipeline, once tiered, costs just under 3 cents per customer versus 12 cents if you go premium across the board: a difference of several hundred dollars a month just from putting the right work with the right model.

Part 8: Applying it to a business: three layers of value, and the familiar boundary

Put the whole course together, and for an executive the value sits in three layers. Layer one: smarter buying. You now have a set of questions to see through any “AI agent” pitch: by what definition of done does the loop stop, how does the rules file evolve, who reviews with a clean context, and is cost tiered across models yet. A vendor who answers those four smoothly is the real thing. Layer two: smarter internal use. The prompt contract and reverse prompting can be applied right away to every employee already using AI, with no infrastructure needed; the 60-30-10 rule can be applied right away to your API bill if the company already runs AI systems. Layer three: a foundation to build on. The crowd techniques (consensus, debate, review loop) are what we use in real, large systems: they turn AI from “a brilliant but moody employee” into “a council with rules of procedure.”

And the boundary, one last time to close the series: this course gives you language and a map; building an agent system that runs real business operations for a company is still an engineering problem: permissions, logs, load handling, someone accountable: exactly the craft of MONA's over 10 years and 14,000+ projects. If you want to turn the map into a machine for your own company, call 1900 636 648 or send it to info@themona.global, and we'll listen to your brief, draw the architecture, and give you a transparent quote: whatever price we sign is the price we deliver at.

Quick answers

How is an AI agent different from a chatbot? A chatbot is a model that answers questions. An agent is a model plus tools, memory and an observe, reason, act loop that runs on its own until it reaches the “definition of done.” One talks, the other does.

Which platform should you start with? One of three: Claude Code (easy to supervise, good for orchestration), Antigravity with Gemini (free, strong at interfaces), Codex (strong at backend). Our course series has a separate lesson for each; the gaps between them are much smaller than the advertising suggests.

Can you take this course without technical skills? Yes, because it's a thinking course: the loop, the prompt contract, reverse prompting and the cost rules are all management matters, not coding matters. For the deep technical parts (MCP, multi-model orchestration), understanding the concept is enough.

Why does AI answer differently every time, and can it be fixed? A model is by nature a probabilistic machine, and that trait can't be “fixed”: but it can be handled through organization: a clear definition of done, the prompt contract, and crowd formations (consensus, debate, three-role review) as in Part 6.

Is running an agent expensive? It depends how you assign the work. A $17-20 monthly plan is enough for deep individual use. For high-volume systems, apply the 60-30-10 rule: cheap models carry the muscle work and the top model keeps only the hard work: the bill usually drops by more than half compared with going premium across the board.

The next course in the series: build your first AI business: take everything you've learned and go find paying customers. See you there.

Homework: build 1 real agent from the MONA Agent template in 30 minutes

Looking at a library of tech resources, the biggest fear for business people is a pile of long, tangled coding theory. In truth, putting machines to work doesn't need to be that complicated. On September 19, 2026, the MONA Agent template library opened fully to the public, completely free, containing 14 AI assistant templates written plainly in Vietnamese for people without technical skills. In essence, we took the same AI Bear family that actually runs for our own company and thousands of clients, then trimmed it down so you can take it home and use it right away. From Smiling Bear for multichannel customer care, Recruiting Bear for processing applications, and Admin Bear that answers anything with real business numbers, to Night Owl Bear quietly sending email. We checked the numbers before writing this.

The whole process from start to a running machine takes only thirty minutes. You start by cloning the open-source repository from GitHub onto your personal computer. Next, you open the window Claude Code, and type the exact Vietnamese command we've prepared so the machine reads the config file and builds the assistant.

This is the make-or-break point: the system file lists only MCP tools that really exist, and never invents function names. We learned that painfully when we let an AI worker run free, and the result was a build that went wrong from the very first foundation step. Once the assistant is built, you can run it directly on your own computer, so your data stays completely safe there.

If you like the result, the system file will take it up to the platform cloud VPS hosted in a Vietnamese data center. Here, the server connects directly to your internal Telegram group through a simple secure code snippet. Unlike outside solutions that promise the moon, you should understand that AI chatbot on Zalo OA requires a very complex technical bridge. Until we've finished building that bridge, we flatly won't make empty promises just to take your money. The template solution suits small businesses that want their own AI assistant, ready to read internal documents and message reports directly. Anyone looking for a magic one-click button should stay away, because everything on the page plainly says this is a trial version still waiting to be finished.

Who to call when you're stuck

A system running day and night doesn't mean you hand everything over to the machine to swim on its own. In real operation there will certainly be moments when a technical flow jams in some baffling way, causing serious damage without an expert stepping in quickly. For example, we tested a top-up flow into the server system on September 17, 2026. Three large models called the tool to generate a VietQR code right inside the chat frame, and the user simply held up a phone to scan. Everything went smoothly until we checked and found two internal products were out of sync on a technical key on September 15, so that money showed as received at the bank while the system balance stood still. The whole team rolled up their sleeves and fixed it that same night, cleaned up the structure and then set a hard rule: every credit notification must be verified by the system with a real transaction before it is opened to customers. We checked the numbers before writing this.

That is why every template pack, even the free ones, comes with a final word of advice: if a flow jams, pick up the phone and call 1900 636 648 so a real person from our team can support you directly in Vietnamese. Unlike using a foreign platform where you pay by Visa/Mastercard that is hard to control and wait on a support team in a different time zone, here you'll use bank API and automatic payment confirmation service payments in Vietnamese dong, with a transparent VAT invoice. For continuous operation, a smart assistant must have a hard budget cap. Our servers come preset with error code 402 so the machine stops immediately when the wallet runs dry, and we commit never to raise the cap on our own and charge a customer more.

If you are an existing business client, we'll advise you separately on the scope of the Webmaster Bear service to plug the machine straight into your order management flow. However, don't expect a robot that can spend money freely without a human reviewing it. Technology only optimizes labor; the right to decide and run the business always stays squarely in your hands.