INEMA Areas v6.2 · 3 modules · 9 lessons of about 15 minutes
eventos.inema.pro organizes the study into nine areas. In each lesson, you understand one of them, see who it serves, and take the first step in your own work. At the end of each lesson, you'll find the area's complete materials if you want to go deeper.

AI Management, AGI-ready, and Cultivated AI: the work shifts to directing, delegating, and cultivating agents.
Claude → Codex, Codex + Claude, and OSWork: where agents work and how to avoid being tied to just one.
RSI, JEV, and WebMCP: improve through testing, decide with clear criteria, and prepare your site for agents.
INEMA Areas v6.2
The course’s technical terms in simple words. Each term links to the lessons where it appears.
an AI that takes on a responsibility and does the work with tools, instead of just answering a question. Example: answering employees’ vacation questions based on company policy.
an AI that takes on a responsibility and does the work with tools, instead of just answering a question. Example: answering employees’ vacation questions based on company policy.
Anthropic’s tool where Claude works directly with a project’s files, reading, writing, and carrying out tasks instead of just chatting.
OpenAI’s tool that serves the same role as Claude Code: an agent that works with a project’s files using OpenAI models.
tests that show whether an AI result meets a success criterion defined in advance. Example: checking whether the notice mentions only coverage included in the contract.
Appears in: Lesson 2
the handoff between one work session and the next: a text with decisions, pending items, and next steps that the next session reads before taking action.
being stuck with a provider because leaving would be costly. Example: being unable to switch tools because your rules exist only within that tool.
Appears in: Lesson 4
the improvement cycle the team uses: execute, observe, critique, propose, experiment, validate, promote, and repeat. Each change that improves things becomes the new version of the process; one that makes things worse is rolled back.
the program that makes the AI work day to day and stores its instructions, memory, and history. Claude Code and Codex are examples.
Appears in: Lesson 4
the practices that help a website appear in search results and be understood clearly by search engines, such as clear titles, descriptions, and text. AI agents read this information too.
Appears in: Lesson 9
a reusable guide the agent loads: instructions, templates, checklists, and examples of how your organization usually handles a task.
the computer’s text window where you type commands instead of clicking buttons.
the unit AI models use to count the text they read and write. Usage is usually charged by the number of tokens.
Appears in: Lesson 1
a way for the page itself to describe to AI agents what it can do, with a name, description, and what each action requires and returns. That way, the agent calls the right action instead of guessing where to click. It is still experimental.
Appears in: Lesson 9
Lesson 1 of 9 · AI Management

You can describe in one sentence what the AI Management area solves and put together a management sheet for an agent in one of your processes.
Setting up an AI assistant has become a one afternoon task. The problem comes later: no one knows who approves what it does, how far it can go, or how much it costs. This area deals with exactly that.
In 1 minute
An agent is an AI that is given a task and carries it out. It can read documents, fill in a spreadsheet, or reply to messages.
The AI Management area starts with an observation. Creating agents has become easy. What holds a company back comes later: who is accountable for the result, what the agent can do on its own, and how to tell if it’s doing well.
Diego discovered that HR already uses three assistants, each set up by a different person. When one of them gave a wrong answer about vacation, no one knew who was responsible.
The area’s page says the logic is the same as traditional people management, with more measurement. A person has a job title, responsibilities, tools, limits, and evaluation. An agent has a role, objective, context, tools, autonomy, and evaluation.
There are two new things. The agent needs written context because it doesn’t learn over coffee. And its autonomy is graduated: it gets an authority limit, a limit on what it can decide on its own.
Sônia took the description of the sales associate who handles the shoe store’s WhatsApp. In twenty minutes, she turned it into an agent sheet for customer service.
Role: WhatsApp customer service.
Limit: discounts only with the manager’s approval.
Evaluation: talks with the manager at the end of the month.
Role: answer questions about sizes, exchanges, and hours.
Context: sizing chart and exchange policy attached.
Authority limit: never offers discounts.
Evaluation: Sônia reads ten conversations a week.
The page uses rules the company already knows. In accounting, the person who enters transactions doesn’t approve them. In legal, the agent prepares things, and the lawyer decides and signs.
For each agent, separate the work into three groups: what it does on its own, what it confirms first, and what it never does.
Diego asked an AI chat to sort the tasks for the vacation assistant.
YouWhat can my vacation assistant do?
AIIt can answer questions, review requests, and approve those that follow the policy…
Without a written limit, “approve” made the list. A person’s decision ended up with the agent.
YouI have an assistant that answers employees’ questions about vacation, with the vacation policy attached below. Separate what it can do into three groups: does on its own, confirms with HR first, never does. [vacation policy attached here]
AIDoes on its own: explain the policy, say how to request time off. Confirms with HR first: respond to cases outside the policy. Never does: approve or deny vacation; change the payroll records.
A person still makes the decision about vacation. The agent goes as far as the door, never beyond it.
Stuck here? That's normalSometimes you don’t know which group a task belongs in. When in doubt, put it in “confirms first.” After a few weeks of reading the responses, you can decide whether it can move up to “does on its own.”
The page’s toughest decision is this: don’t put agents to work carrying out old processes faster. Many steps exist only because there used to be no other way. Speeding up those steps delivers the mistake sooner.
The question for the team is simple. If I had people, agents, and automations today, would this process still exist this way?
Sônia was going to have an agent copy WhatsApp orders into a spreadsheet, as the sales associate did by hand. She stopped first and asked whether the spreadsheet was still necessary.
The agent copies each WhatsApp order into the spreadsheet, which the sales associate checks and transfers to the inventory list.
Three copies of the same information, now faster.
The agent records the request directly in the inventory list. The sales associate only checks requests involving exchanges.
Just one copy, and the person handles the difficult case.
LOOP-R is the cycle the department uses to keep the process moving forward. Each run produces an improvement proposal. If the change improves the result, it becomes the new version. If it makes things worse, the previous version is restored.
Test yourself
A team built an agent in one afternoon. It already runs the old approval process, just faster. What would the department say?
Practice now 0/3
You’re done when you have a sheet with an owner, an authority limit, and three ways to measure performance. About 10 minutes.
Describe the process without customer names or personal data. If the answer is generic, add a real step from your process and ask again.
Read the page https://eventos.inema.pro/gestao-ia/ (the INEMA AI Management area). My process: <describe the process and who does each step today> The agent I’m thinking of using: <what it would do> Provide: 1) Whether this process should still exist in this form, and what I would cut. 2) What the agent does on its own, what it confirms first, and what it never executes. 3) Who should approve its result. 4) Three ways to measure whether it’s doing well. Don’t make up information about my process: ask if anything is missing.
My process: An employee emails a question about vacation; someone in HR reads the policy and replies within two days.
The agent I’m thinking of using: Answer common questions based on the pasted vacation policy.
You’ve just treated an agent as something to manage, not just build.
Lesson cheat sheet
The area opens with the sentence “In 2026, we taught people to create agents. 2027 is the year to learn how to manage them.” Managing an agent means assigning it a role, objective, context, tools, authority limit, and evaluation, just as you always have with people. The page proposes redesigning the company for the speed of agents instead of speeding up old processes.
The area brings together the thesis, the 8 AI manager competencies, LOOP-R, the AI Management Training 2027, and INEMA courses and projects that already cover most of the path.
The page shows the eras of management. From 1980 to 2000, people management. From 2000 to 2020, process management. From 2020 to 2025, digital transformation. From 2025 to 2026, agent building.
In 2027, management coordinates people, agents, models, processes, and computing budget at the same time. Building the agent itself is covered in the AGI-ready area.
Employee, job title, responsibility, tools, limits, and evaluation become agent, role, objective, context, tools, autonomy, and evaluation. Two new items are added: explicit context and graduated autonomy.
Examples from the page: in accounting, the person who enters a transaction doesn’t approve it. In law, the agent prepares the work, and the lawyer decides and signs. In healthcare, some decisions are outside the agent’s authority limit.
Strategy: what result do we want? Work design: should this process still exist? Delegation: what should we hand over to the agent? Orchestration: one agent or several, in sequence or in parallel?
Governance: what can it do on its own, what must it confirm, and what must it never do? Economics: how much does it cost to produce the result? Evaluation: is it good, compared with what? Evolution: what did we learn from this run?
The page sums up the economics: a cheap agent that makes mistakes and needs two attempts cost twice as much as the listed price. That’s why it measures cost per result, not just the price per token.
The page compares four generations of processes: traditional, automated, agentic, and the process with LOOP-R. In the last one, the process becomes a living system with versions.
There are three rules: don’t automate a bad process; people direct, agents execute; promotion and rollback are steps, not accidents.
The AI Management Training 2027 has ten modules and a final project, with the AI Management course as its backbone. The final project is Gestoria, a simulator for managing an agentic company.
The page is honest: the training packages a thesis, and 75% to 80% of the foundation already exists in open courses and projects. The best first module, the area says, is a process from your company.
Sources: AI Management Area · AI Management Course · Gestoria · LOOP-R
Lesson 1 · INEMA Areas v6.2 · INEMA.CLUB PRO
Lesson 2 of 9 · AGI-ready

You can rewrite a request to AI as a delegation with five parts: goal, what matters, limits, resources, and how to tell when it’s good.
Many people still use AI like they’re dictating a recipe, step by step. When a step is missing, the result is wrong. The AGI-ready area shows another way: say where you want to end up and let AI find the path.
In 1 minute
The page recalls that for three years, we tried to fit the entire operation into one giant request. Today, there are agents that work for hours or days. In that case, you state the destination and the agent finds the path.
The change at your desk is the unit of the request. A task says what to do now. A responsibility says what to take care of, and the agent plans, carries it out, and returns with the result.
Sônia picked up the counter notebook and rewrote three requests she made to AI every week. The list changed its verbs.
Write a message about Saturday’s promotion.
Make a list of the sneakers that are out of stock.
Reply to this customer about the exchange.
Take care of promoting deals on WhatsApp.
Take care of the inventory restocking list.
Take care of exchange questions, within the store’s policy.
The page doesn’t say the request is over. It says the request that tries to teach every step is over. The new request has five parts: goal, what matters, what must not happen, available resources, and how you’ll judge the result.
Diego wrote a twelve-step request to prepare the announcement about the health plan change. Every time, a detail was missing. He replaced the steps with the five parts.
YouGoal: employees understand the health plan change without needing to call HR. What matters: simple language and what changes for each person. What must not happen: promising coverage that isn’t in the contract. Resources: the summary of the new contract, pasted below. How I’ll judge: someone outside HR reads it and understands it in two minutes. Before writing, show me a plan.
AIPlan: 1) list what changes, based on the summary; 2) separate it by employee type; 3) write short sentences; 4) mark what isn’t clear in the summary for you to confirm.
The plan comes before the text. Diego checks that it respects the limit before the AI writes a single line.
Stuck here? That's normalThe hardest part is usually “how will I judge it?” Think about who will use the result and write down what that person needs to be able to do with it.
Delegating doesn’t mean letting go of everything or locking everything down. The page introduces the trust matrix, with three levels: what the agent decides on its own, what it proposes for you to approve, and what it never touches. Each level has an owner.
Sônia created the matrix for the responsibility of restocking inventory.
The request says what you want now. The way to do it well, which stays the same, goes into a Skill. The page’s tip: if you’ve explained the same procedure three times, turn it into a Skill. In a regular chat, you can start simple: save some text in Notes and paste it along with your request.
Diego realized he was always explaining the same writing rules for HR announcements. He separated the request into two columns.
The announcement topic.
The source document.
Who it’s for.
Tone and sentence length.
Title and signature template.
Checklist before sending.
The page organizes the agent into steps: intent (why), objective (what), request, Skill, context, tools, memory, and at the top, permissions and evals. When something goes wrong, the ladder shows which step is missing: context, a Skill, or a criterion.
Test yourself
Your request to AI has 30 numbered steps, and the result still comes out wrong when one step is missing. What does the AGI-ready area propose?
Practice now 0/3
You’re done when you have a request of your own with all five parts and a trust matrix. About 10 minutes.
Don’t paste client names or personal data. If the answer is generic, add a real detail from your work and ask again.
Read the page https://eventos.inema.pro/agi-ready/ (INEMA’s AGI-ready area). My request today, in my own words: <paste one of your requests to AI here> My work and what already exists: <area, tools, and documents I have> Rewrite it as a delegation, with five parts: objective, what matters, what must not happen, available resources, and how I’ll judge the result. Then: 1) Build the trust matrix: decides alone | proposes and I approve | never touches. 2) Point out what is always the same and could become a reusable manual. Don’t make up information about my work: ask if anything is missing.
My request today: Write a WhatsApp message letting customers know about Saturday’s promotion.
My work and what already exists: neighborhood shoe store, WhatsApp broadcast list, and the promotion price list.
You just replaced a recipe with a delegation.
Lesson cheat sheet
The area opens with the sentence “AI has stopped waiting for orders. Your work becomes directing agents.”
With agents that work for hours or days, you state the destination and the agent figures out the path, without programming.
The page describes six changes: three from the labs and three at your desk.
At your desk: tasks become responsibilities, trust becomes a curve, and your value shifts to objectives, limits, and judgment.
The page cites, as an external reference, a video in English about the article “Alien Minds,” by Jakub Pachocki of OpenAI.
The request doesn't disappear. What disappears is the request that teaches every step, as people did between 2023 and 2025.
A request is what you want now; a Skill is how the organization usually does it, with templates and examples.
Intent, goal, request, Skill, context, tools, memory, and at the top, permissions and evals.
In the page's example, an agent with five Skills receives a short sentence and does a lot of work because the how is already in place.
The page's summary: we don't just want a powerful agent; we want a controllable agent.
Separate tasks from responsibilities. Rewrite a request as a delegation and ask for a plan before acting.
Turn into a Skill what you've explained three times. Write the trust matrix.
Give context before giving tools. Define what “good” means before running it.
To get started: The Super-Agents Have Arrived, Super-Agents in Practice, and AI Work Architect.
There are also projects with guides, such as the Agent Architect Kit, and three entry points: INEMA.CLUB, INEMA.VIP, and INEMA.PRO.
Sources: AGI-ready Area · The Super-Agents Have Arrived · Super-Agents in Practice · Agent Architect Kit
Lesson 2 · INEMA Areas v6.2 · INEMA.CLUB PRO
Lesson 3 of 9 · Cultivated AI

You can explain why your AI improves because of the environment around it and create a sheet for your own agent with the eight elements of cultivation.
Many people complain that “AI doesn't learn.” The model, in fact, doesn't learn on its own as you use it. What improves is what you write and adjust around it. This area teaches you how to take care of that.
In 1 minute
The area opens with a sentence: “Before, we programmed behavior. Now, we program the process that produces behavior.”
The page separates two levels. At the first, the lab cultivates the model, and you don't take part. At the second, you cultivate the agent: the model comes ready, and what changes is the environment around it. The page calls this environment a garden.
Diego and a colleague use the same AI chat to write internal announcements. Hers come out in the company's tone; his are generic.
Open the chat and ask, "Write an announcement about the new hours."
Nothing written about the company, no examples.
Pastes a page about the company, two previously approved announcements, and three tone rules.
Same model, different garden.
Every agent, personal or for a company, is cultivated with the same eight ingredients: role, context, tools, rules and limits, examples, memory, evaluation, and feedback.
The first four make the agent work. The last four help it improve. The page notes that most people stop at the fourth and then complain that AI doesn't learn.
Sônia uses AI to write descriptions of shoes for the store's website. She marked what she had in writing.
The heart of the method is the cycle: the agent works, you evaluate, the failure becomes an adjustment to the environment, and the agent improves. The page calls each round a harvest.
Two rules support the cycle. Evaluation produces lines, not impressions: one line for each failure, in a log. And the fix goes in the file, not in the conversation, because the conversation gets lost. The file is a text document you keep in Notes or another document, which you paste at the start of each conversation with AI.
Diego opened the failure log for the announcement agent, with the page's four columns.
Stuck here? That's normalNot sure whether a failure is an "instruction" issue (you didn't tell the AI something) or an "infrastructure" issue (the tool failed: it didn't open the file, or it crashed)? Write the line anyway and leave the last column blank. What matters is recording it; during your weekly review, you can decide.
The page defines three levels. At level 1, the agent suggests and you carry it out. At level 2, it acts and you review. At level 3, it acts and reports. Every agent starts at level 1, never at 3.
Everything fits in five text files: the agent sheet, the context, the annotated examples, the failure log, and the weekly review scorecard, where you decide whether to keep it at its level, move it up, or move it back down.
Sônia asked an AI chat to say which level the agent for descriptions should start at.
YouMy agent writes descriptions of the store’s new shoes for the website. Which of the three levels should it start at: suggests and I carry it out, acts and I review, or acts and reports?
AIIt starts at level 1: it suggests the description and you publish it. Move it up to level 2 only after a few weeks with no new failures in the log.
The answer promises no timeframe or number. It ties moving up a level to the log.
Test yourself
After a month, you say that “your AI got better,” but the model is the same. What improved, according to the area?
Practice now 0/3
You’re ready when you have a v1.0 sheet with the eight elements and the failure log header. About 10 minutes.
Describe the task without customer names or personal data. If the AI writes <fill in>, that’s fine: it’s a sign that it didn’t make anything up.
Read the page https://eventos.inema.pro/ia-cultivada/ (INEMA’s Cultivated AI area). My garden: <personal life or work> The agent’s only function: <one responsibility> What I already have: <documents, examples, tools> Create the agent sheet with the eight elements: function, context, tools, rules and limits (does on its own, asks for confirmation, never does), examples, memory, evaluation, and feedback. Add version v1.0 and today’s date. Then write the failure log header: date | what broke | smallest fix | instruction or infrastructure. Start at level 1: the agent suggests, I carry it out. Where information is missing, write <fill in> instead of making it up.
My garden: work.
The agent’s only function: draft internal HR announcements.
What I already have: three approved old announcements and the company tone guide.
You’ve just planted a garden: the sheet is the starting point for the cycle.
Lesson cheat sheet
No one writes a large model's capabilities line by line: the lab creates the conditions, and they emerge. That's level 1.
At level 2, you cultivate the agent. The model arrives with frozen weights; what learns is the system around it.
Role: one at a time. Context: one good page is worth more than twenty dumped in. Tools, starting with reading. Rules and limits.
Real examples with notes, including the bad ones. Memory between sessions. Evaluation: good compared to what? Feedback: every failure leads to a change in the file.
Between harvests, the model doesn't change; what you noted and adjusted in the environment changes.
Example from the page: an agent that drafts collection emails stays at level 1 for three weeks, with no new failures, before moving to level 2.
For your personal life, three or four text files and a weekly 20-minute review are enough, across five areas: decisions, health and routine, money, study, writing.
Jarvis is the popular name for a personal assistant that takes action: it works with files, calendar, and messages. The page calls for care: outside content is data, not an instruction.
Rigid automation breaks at the first unexpected case; a cultivated agent gets a role, criteria, examples, and limits. One process, one agent, one metric.
Diagnosis from the page: “the agent hallucinates” means missing or cluttered context; “it stopped improving” means feedback that doesn't make it back into the environment.
Agent sheet, context, annotated examples, failure log, and weekly scoreboard. The same in the personal garden and the company garden.
The area brings together the Cultivated AI course, the personal, Jarvis, and company kits, the sheet generator, and an eight-question maturity assessment.
Sources: Cultivated AI Area · Cultivated AI Course · Kits · Assessment
Lesson 3 · INEMA Areas v6.2 · INEMA.CLUB PRO
Lesson 4 of 9 · Claude → Codex

You can find where your way of working with AI is locked in and put everything into one document that any model can read.
Anyone who has used the same AI for months has taught it a lot: rules, preferences, decisions. Almost always, this is stored only inside that tool. The day you switch, you start from scratch. This area shows you how to avoid that.
In 1 minute
The area discusses two tools for programming with AI. Claude Code is one. Codex is the other.
The "brain" is everything you’ve accumulated in a project: context, rules, decisions, tasks, and memory. The area advocates keeping this in plain text that any AI can read.
Sônia has been using the same AI chat for months to write the store’s messages. One day, she thought about trying another chat and realized she didn’t know what the first one "knew."
The page says: "The lock-in isn’t in the model. It’s in what you left inside the runtime." Runtime is the program where the AI runs and stores its memory and history.
The area’s rule is simple: the content lasts; the format is disposable. Mixing the two is what makes switching difficult.
Diego discovered that the rule for writing job postings existed only in the chat’s memory. No one else in HR knew about it.
The job posting rule is in the chat’s memory.
If HR switches chats, the rule disappears, and no one knows why.
The rule is in an HR document, in plain text.
Any chat can read the same document and follow the same rule.
The area’s method has four steps, in this order. Audit means listing what exists, without changing anything. Adapt means separating what works with any AI from what only works in that tool. For example: “exchanges only with a receipt” works with any AI; a button or shortcut that exists only in that app doesn’t carry over.
Test means opening a new conversation and checking whether the AI uses the document. The last step is the handoff: a text with decisions, pending items, and the next step.
Sônia pasted the store document into a new chat and asked a test question.
YouRead the document below before answering. A customer wants to exchange a pair of shoes without the receipt. What should I say? Tell me which part of the document the rule came from. [store document pasted here]
AIAccording to the rule “Exchanges only with a receipt,” the exchange can’t be made without the receipt. Here’s a suggested response in the friendly, no-slang tone the document calls for.
The AI cited the rule from the document. That’s the proof: it’s not enough for the document to exist; the AI needs to use it.
Stuck here? That's normalYou don’t need to go through all four steps today. The first one, listing what exists, already shows what you could lose in a switch. You can do the rest later.
The page breaks the decision into three effort levels. Level 1: import into the app itself with one click, limited to what the other side accepts. Level 2: migrate with the area’s kit, a set of ready-made requests that makes the move without deleting anything.
Level 3: the knowledge lives in the project, and the tool becomes just the one that carries out the work. According to the page, it’s the only level that survives the next switch. That doesn’t mean abandoning the AI you use today: you choose the tool for each task.
Diego isn’t switching chats now. Even so, he saved the HR rules in a document so he wouldn’t depend on just one.
One click in the new app brings over part of what the old one knew.
Only what the other side accepts comes over.
Diego’s HR rules stay in a document.
Any chat can read the document; the tool just carries out the work.
In programming projects, the rules are kept in text files inside the project folder. CLAUDE.md is read only by Claude Code; AGENTS.md works with several agents. The area suggests starting with a request that only reads and lists, without changing anything:
MODE: audit Sem alterar nenhum arquivo, faça um inventário deste projeto. Devolva só o relatório e um plano. Não implemente nada.
Test yourself
A colleague says switching AI tools is just copying instructions from one place to another. What’s missing from that idea?
Practice now 0/3
You’re done when you have a document with your instructions, preferences, and decisions, tested in a new chat. About 8 minutes.
Don’t put passwords, customer data, or personal information in the document. It’s for rules and preferences, not secrets.
How I work with AI Instructions (what AI should always do): - <ex.: write in a warm tone, without slang> Preferences (what I like in the result): - <ex.: short answers, in bullet points> Decisions (what’s already been settled and shouldn’t be discussed again): - <ex.: exchanges only with a receipt> Next step: - <what I’m doing with AI now>
Instructions: warm tone, no slang; never promise a delivery date.
Preferences: short messages that fit on one WhatsApp screen.
Decisions: exchanges only with a receipt.
Next step: messages for the new collection.
The way you work with AI is now yours, not just the tool’s.
Lesson cheat sheet
The “brain” is what you’ve built up in a project: context, rules, decisions, tasks, handoffs, and memory. According to the page, only CLAUDE.md and AGENTS.md are tied to the provider.
The rest is plain text in Markdown, which any AI can read. With that, Claude Code, Codex, Gemini, or a local model become just executors. Switching models means changing the outer layer, not the core.
Anyone who has used an assistant for months has built up instructions, memory, and sessions in a format only that runtime can read. The dependency stays invisible until it’s time to switch.
The page sums it up: the content lasts; the format is disposable. Session history stores the work, but it isn’t the work.
Audit, Adapt, Prove, and Handoff, in that order, "never implementing before auditing." Audit only reads and classifies. Adapt divides the CLAUDE.md between what is portable and what is leftover.
Prove means opening a new session and asking five questions: the goal and what counts as done, one rule and its source, the last decision, the next action, and conflicts. The file existing is not proof.
There are seven places, each with an owner. AGENTS.md contains the rules and reading order. There is also verified context, current state, sources, decisions, the current task, and the most recent handoff.
Each piece of information has a type: fact, preference, hypothesis, or decision. The source matters more than the date, and nothing is deleted: an old decision is simply marked as superseded.
Level 1: import into the app, with one click and limited. Level 2: migrate with the area kit. Level 3: the portable personal layer, where the tool can be swapped out.
Staying tool-agnostic, without depending on a specific model, is level 3. The page lists when to migrate right away and when to stay tool-agnostic, such as when you use two tools.
The Claude → Codex course is open and in Portuguese, with English and Spanish versions: 3 tracks, 18 modules, and 108 topics. The agente-claude-codex kit does the work without deleting anything.
The page sums it up: "The best first step is one of your own projects, in audit mode."
Sources: Claude → Codex Area · Claude → Codex Course · agente-claude-codex kit guide · Topic map
Lesson 4 · INEMA Areas v6.2 · INEMA.CLUB PRO
Lesson 5 of 9 · Codex + Claude

You can ask one AI to review what another did and get the findings along with the smallest fix for each one.
People who write a text tend to approve their own work, and the same thing happens with AI. A second look from another model catches issues the author misses. This area teaches you to set up that second look without making things complicated.
In 1 minute
The Codex + Claude area is about two AIs from different companies. Claude is from Anthropic. Codex is from OpenAI, the same company as ChatGPT. The page doesn't ask you to choose one; it asks you to use both, each for a different part.
The reason is simple. If the same AI writes and reviews in the same conversation, it tends to think everything is fine. Two AIs agreeing is not proof either. The test and your approval are what count.
Diego asked an AI for a welcome message for the new hires. Then, in the same conversation, he asked whether the message was good.
YouIs this welcome message you wrote any good?
AIYes, it’s clear, welcoming, and complete.
That answer says nothing. People rarely spot their own mistakes.
The rule that applies across the board: the second assistant gets the same request the first one got and the actual text it produced. Don’t say, “The other AI wrote something about vacation. Is it good?” Without the original, the review becomes a guess.
Sônia asked an AI for a WhatsApp message telling customers about the winter sale. To review it, she opened another AI and pasted in both things.
“An AI wrote a sale announcement for my store. Is it good?”
The reviewer hasn’t seen the text and doesn’t know what was requested.
Original request: a short sale announcement with the store hours and exchange policy.
Text produced: the entire message, pasted in.
Now the reviewer can compare what was requested with what came out.
A good review doesn’t rewrite everything. It lists findings: what’s wrong, where it is, why it matters, and the smallest fix that solves it. That way, you can decide on each item without losing the text that was already working.
Sônia asked for findings, not a new text.
YouOriginal request: a short sale announcement with the store hours and exchange policy. Text written by another AI: [message pasted here] Review it by reading only. List the findings: the problem, why it matters, and the smallest fix. Don’t rewrite the whole text.
AIFinding 1: the exchange policy is missing, even though it was in the request. Smallest fix: add a line with the policy. Finding 2: the store hours are missing. Smallest fix: include the hours in the last sentence. The rest meets the request.
Two findings, each with a small fix. Sônia accepts, rejects, or leaves each one pending.
Stuck here? That's normalSometimes the reviewer points out things you don’t think are important. You don’t have to accept everything. Mark each finding as resolved, rejected with a short reason, or pending.
The page sets a limit: no more than two rounds. In the first, the reviewer points things out; you make corrections. In the second, it checks the corrections. After that, the decision is yours. Endless rounds just waste time.
The last step is a handoff: a short note with the status, decisions, and next action. Whoever picks this up tomorrow, you or another AI, reads it before taking action.
Diego finished reviewing the welcome text with three lines in Notes: "Text approved in round 2. I rejected the finding about the formal tone. Still to do: send it to the manager."
StatusText approved in round 2.
DecisionI rejected the finding about the formal tone.
Next actionSend it to the manager.
Three lines are enough. Anyone who opens it tomorrow can see where things stopped without rereading the conversation.
Anyone who already uses Codex and Claude Code can do the same review directly in the terminal. The first command asks Codex to review a plan by reading only and save the review to a file. The second does the reverse, with Claude reviewing.
codex exec --sandbox read-only -c model_reasoning_effort=medium \ --output-last-message review.md \ 'Leia plan-v1.md. Aponte falhas de correção e testes faltando, com evidência, impacto e a menor correção. Não altere arquivos.' claude -p --model opus --effort medium \ 'Leia plan-v1.md e revise só lendo: falhas, suposições e testes faltando. Não altere arquivos.' > review-claude.md
Check afterward that the review file was created and that the original plan did not change.
Test yourself
An AI wrote a plan, and the same AI approved it in the same conversation. Why isn’t that enough?
Practice now 0/3
You’re done when you have a list of findings with the smallest fix for each one and your decision next to it. About 8 minutes.
Use text with no client names or personal data. If the review rewrites everything, repeat the last line of the request: "findings only, don’t rewrite".
You’re going to review text written by another AI. Review it by reading only. Original request the other AI received: <paste what you asked here> Text it delivered: <paste the entire text here> Provide a list of findings. For each one: 1) The problem and where it appears. 2) Why it matters. 3) The smallest fix that resolves it. At the end, say what already meets the request. Don’t rewrite the entire text or make up facts: ask when information is missing.
Original request: a short winter sale notice for customers on WhatsApp, with store hours and the exchange policy.
Text it delivered: the entire message the first AI wrote, pasted without cuts.
You just used one AI to check another, and you made the final decision.
Lesson cheat sheet
The area’s thesis is “One plans, the other critiques. Use both together.” Each AI handles one part, and the other checks the actual material.
This page is for people who already use both and don’t want to choose just one. To switch from one to the other, go to the Claude → Codex area.
The Use Both kit organizes using both together into six levels, with ready-to-use requests. Level 1: one writes the plan, the other critiques it, in up to two rounds.
Level 2, optional: generate images, checking access and billing first. Level 3: one builds, the other reviews the changes using the test results.
Level 4: supervised use of the computer, with passwords and payments under your control. Level 5: a goal with a stopping condition. Level 6: a handoff note and a review by the next AI.
For each task, the card says who takes the first pass, who takes the second, and what counts as the finish line.
Example: for planning, Claude makes the plan and Codex critiques the assumptions. The page notes that these are editorial choices, not a measured model ranking.
The page’s path is to understand, migrate or stay neutral, use both together, and automate the debate.
claudex is a program: Claude writes the plan and Codex critiques it repeatedly, until it’s approved or until N rounds. Use Both is a method, with a guide and templates.
The page sums it up: they complement each other. For a big plan, use claudex; for reviewing changes, a goal with a stopping condition, and switching sessions, use Use Both.
“The best first step: a plan of your own, reviewed by the other.” A small task, acceptance criteria, two rounds, and a handoff note before you wrap up.
The area brings together six courses: Claude → Codex, Codex Básico, Master Codex, iClaudeX, MakeClaudeX, and DeepClaudeX. It mentions an external video by Mark Kashef for reference only.
Sources: Codex + Claude Area · Use Both Guide · claudex · Claude → Codex Course
Lesson 5 · INEMA Areas v6.2 · INEMA.CLUB PRO
Lesson 6 of 9 · OSWork

You can choose the right OSWork edition for where you are now and cite the sentence on the page that supports your choice.
Requests, reviews, and notes pile up, and every conversation with AI starts from scratch. OSWork teaches you to keep it all in a work system. The course comes in five editions, and starting with the wrong one can make you give up at the first obstacle or get bored with the basics.
In 1 minute
OSWork presents itself as "AI as a work system" and "from chat to your environment of agents". The idea is to organize files, instructions, and memory so AI doesn’t have to hear everything again in each conversation.
The method has four steps: define the goal, choose the context, do a small task, and check the result.
Every Monday, Sônia asks for the week’s promotion text. And every Monday, she explains the store’s name, tone, and exchange rules all over again.
She opens the chat, types the same explanations, gets the text, and closes it.
The following week, she starts from scratch.
A store folder with the rules written down once and the texts already approved.
The next conversation already starts with the right context.
The page offers "five ways to organize your work with AI" and asks you to choose based on your experience and available time. The same idea is presented in different levels of depth.
Numbers and scope are taken from the area page. The difference between v6 and v6.2: v6 stops at folders and the sheet; v6.2 goes as far as the bot, like v2.
According to the page, there are courses and videos in Portuguese, Spanish, and English. v6.2 and v6 have their own links in English and Spanish.
The first question: how far do I want to go? The complete path (v2 and v6.2) goes from chat to a consultation bot on Telegram. It ends with supervised operation on a rented computer on the internet. The editions for beginners (v6, v5, and Quick) stop earlier: folders by topic, a sheet with your rules, reusable requests, and a review routine.
The second: How much technical background do I have? v2 uses the terminal and Codex. v6.2 follows the same path in short, visual lessons, for people who have never opened one.
Diego wants a robot in the future that answers the team's questions through Telegram, but he has never used the terminal. He answered both questions.
How farI want to get to a query robot on Telegram.
Technical backgroundI've never used the terminal.
ChoiceOSWork v6.2: the same path as v2, in lessons of about 15 minutes, with visual step-by-step instructions and a glossary.
The choice cites what the page says about v6.2. Nothing made up.
Stuck here? That's normalCan't decide between two editions? First check whether both get you where you want to go; rule out the one that stops short. If both get you there, choose the shorter one. You can move on to another later.
The page says: "Start with a small task." There are three steps: choose where to start; create a practice folder and write a few lines in it about what the task should deliver; save the result, write down a question, and move on to the next lesson.
Two answers in the "Before you start" section ease your worries: you can start with the fundamentals without programming, and you can read the content without signing up. AI subscriptions and renting a computer on the internet are separate services that you choose. And the course does not promise an unsupervised autonomous agent.
Sônia created a folder on her computer called "Treino OSWork". Inside, she saved the week's promotions text and a question.
File 1promocoes-da-semana.txt: the approved text for this Monday.
File 2duvidas.txt: "How do I save the store's tone so I don't have to explain it again?"
One saved result and one written question: the first small task is done.
Test yourself
A 45-year-old with little familiarity with AI and little time wants to get started. Which edition does the page recommend?
Practice now 0/3
You're done when you've chosen an edition for each person, with the sentence from the lesson table that justifies it, and then chosen yours. About 8 minutes. Write it down on paper or in your notes.
These are fictional people created for practice. Disagree with the answer key? Go back to the table in step 2 and check each edition.
The case (fictional): A small company wants three people to take OSWork. Marta, 52, handles finances, barely uses AI, and has one free hour a week. Paulo, 29, is a developer, uses the terminal every day, and wants to build a query robot. Lia, 38, is a project assistant, already uses AI chat, has never opened a terminal, and wants to get to the same robot as Paulo, at a relaxed pace.
You’ve just chosen an edition based on experience, time, and goal, using the page as evidence.
Lesson cheat sheet
OSWork organizes files, instructions, memory, and tools into a work system you can check.
Without organization, every conversation starts from scratch. With a project folder and your own instructions, the next one starts with context.
v2 is technical; v6.2 is complete, step by step; v6 is visual for beginners; v5 is for beginners 40+; Quick gets straight to the point.
On a team, the developer follows v2 while the coordinator, who has no experience, starts with Quick. The logic is the same.
Eight modules: Models; Chat, Work, and Desktop; Terminal and Codex; Folders and secrets; AGENTS, Skills, and memory; versions without losing work; Telegram; 24/7 operation.
v6.2 covers this track in 48 lessons of about 15 minutes, with visual step-by-step instructions and a glossary.
v6 has seven visual lessons of about 15 minutes. v5 has seven lessons of 20 to 25 minutes, with no programming.
Quick has seven lessons, about 77 minutes, and is available as a video with an avatar and Nei’s voice in three languages.
A project folder, a record of decisions and mistakes, a version history, and a lookup robot using fictional data.
"Your first environment starts with real files." The kit includes ready-to-use templates, such as the task agreement and the mistake log.
Choose the first module, create a practice folder, adapt the task agreement, and save the result with a question.
Read without signing up; paid services are separate. The course teaches limits, verification, and recovery, not unsupervised autonomy.
Sources: OSWork Area · OSWork v2 · OSWork v6.2 · OSWork Quick videos
Lesson 6 · INEMA Areas v6.2 · INEMA.CLUB PRO
Lesson 7 of 9 · RSI

You can run a short improvement cycle on one of your requests: one change, tested before and after on the same examples, with a way to go back.
Everyone has adjusted an AI request by eye and thought it got better. The RSI area shows how to turn that impression into a test anyone on the team can check.
In 1 minute
The RSI area explores a practical question: how an AI system proposes changes, tests the result, and keeps what works. The page separates three levels.
At the first level, AI reviews the response: it critiques and rewrites what it wrote. This can improve a task without changing the model. At the second, it changes the system: the instruction, memory, or tools of the agent. At the third, investigating recursion, the improvement starts helping produce future improvements, and that calls for strong evidence.
A salesperson offered Sônia a virtual assistant that "learns on its own." She wrote down the promise and asked one question for each level.
The page suggests starting small. Choose a task, such as pulling action items from meeting minutes. Write the correct answer for three made-up examples.
Then separate the examples into two groups. Two are for adjusting the request. One is reserved: you only use it at the end to check whether the change holds up.
Diego uses AI to extract action items from the HR team’s weekly meeting minutes. Sometimes it forgets who is responsible for each action. Before changing the request, he prepared the test sheet.
Suggest one change to the request. Run the old and new versions on the same meeting minutes. Note the correct answers, errors, and how long you took to review each one.
If you change three things at once and the result improves, you won’t know which one helped. And if it gets worse, you won’t know that either.
Diego’s change was one sentence: "If the meeting minutes don’t say who is responsible, write 'no one assigned' instead of guessing."
Minutes A: ✓ three actions, ✓ people responsible.
Minutes B: ✗ listed a person responsible who wasn’t mentioned in the minutes.
Review: Diego had to reread all of Minutes B.
Minutes A: ✓ three actions, ✓ people responsible.
Minutes B: ✓ marked "no one assigned" for the action without a name.
Review: he only had to look at the marked line.
Stuck here? That's normalSometimes the two versions tie. That’s a result too: the change didn’t help, and the old request still applies. Make a note and try another change another day.
Only now run the new version on the reserved meeting minutes. If it gets those right too, you can adopt it. Note who decided and where the old version is.
The team calls this a cycle with safeguards. LOOP-R, the cycle proposed by the project, has an explicit rule: no worse version can replace the current one based on a system decision.
Version 2 also got the answers right on Minutes C. Diego adopted the new version, wrote "approved by Diego," and left Version 1 in the same folder with the date.
YouI ran Version 1 and Version 2 of my request on Minutes A and B, and Version 2 on Minutes C, which I had reserved. My results are below. Can I adopt Version 2? Don’t make up results. [results pasted here]
AIBased on the results you pasted, version 2 got all three meeting minutes right, including the reserved one. You can adopt it. First, record who made the decision and keep version 1 so you can go back if a new error appears.
AI only read Diego’s results. He’s the one who decides whether to switch.
Test yourself
After ten attempts, the new instruction scored higher on the same examples you used to adjust it. Does that prove it’s better?
Practice now 0/3
You’re done when you have a sheet with three examples, one change, and the results from both versions. About 10 minutes.
Use made-up examples, without customer names or personal data. If AI fills in results for you, erase them and ask again with the fields blank.
Read the page https://eventos.inema.pro/rsi/ (INEMA's RSI area). I want to test ONE improvement to a request I use at work. My task: <e.g.: list the action items from meeting minutes> My current request: <paste the request you use today> Provide: 1) Which of the three levels my idea falls under (revise the response, improve the system, investigate recursion). 2) Three made-up examples of the task, each with a blank space for ME to write the correct answer. Mark one as reserved. 3) ONE change to my request. 4) A table to compare both versions: correct answers, errors, and review time. 5) Who should decide whether to adopt it and how to go back to the old request. Don't make up results: leave the result fields blank for me to fill in.
My task: write a shoe description for the store's website based on the supplier's notes.
My current request: "Write a short, friendly description of this shoe based on the notes below."
Correct answer, written by her: the description mentions the material, color, and size range, is up to 3 lines long, and doesn't make anything up beyond what's in the notes.
You just replaced "I think it's better" with a test someone else can check.
Lesson cheat sheet
RSI is recursive self-improvement: AI that helps improve AI itself. The page presents the topic as a field of study and an open collection of resources.
When you hear an AI promise that it “learns on its own,” ask what exactly improved and what evidence supports that claim.
Reviewing a response can improve a task without changing the model. Improving the system changes instructions, memory, or tools and calls for comparing versions.
Investigating recursion calls for strong evidence: more attempts or a higher score do not demonstrate unlimited growth.
Define the task, the correct answer, and the limits on data, spending, and actions. Record the initial version and set examples aside for testing.
Change one thing at a time, use the same criteria, and validate before adopting it. You can explore a well-known evaluation.
The page describes LOOP-R, ready to use in Claude Code, with nine assistants, version tracking, a spending cap, and a command to revert.
In the RSI course, it appears as a conceptual proposal. There is also a LOOP-R course with five tracks and 21 lessons for managers without a technical background.
The RSI v6.2 course has 18 lessons in six modules. The RSI Guide maps mechanisms, applications, and limits. Both are available in Portuguese, English, and Spanish.
Page disclaimer: the project brings together research and educational content. It is not an autonomous RSI system ready to run.
RSI Copiloto compares instructions, requests human review, and lets you revert. The public demonstration uses preprogrammed examples, without AI; real AI is only in the local version.
Dream-RSI is an independent educational guide, not affiliated with Google; the lab and the eight sessions are future plans.
Alerta IA 2028 treats the 2028 scenarios as hypotheses, with no guaranteed timeline. References such as Self-Refine and AlphaEvolve have not been reproduced in the project.
Sources: RSI Area · RSI Course v6.2 · RSI Guide · LOOP-R
Lesson 7 · INEMA Areas v6.2 · INEMA.CLUB PRO
Lesson 8 of 9 · JEV

You can set up a decision with alternatives and criteria, ask an AI to choose, and check whether its choice deserves to be followed.
Many everyday tasks call for a decision, not a piece of writing: who should receive this email, or is this request urgent? When the question is open-ended, the answer comes back as a paragraph that is hard to use and check. This area teaches you how to make the question specific.
In 1 minute
Jev is TypeSafe’s structured decision model, made by the company TypeSafe. Jev Decision Lab is INEMA’s educational project for learning how to formulate these questions. The central idea: AI receives context and criteria and returns a choice, a probability, or a level. Your process takes action afterward, not AI.
Sônia needs to restock children’s sneakers and is unsure which of two orders to place with the supplier. First, she asked the usual way.
"What do you think I should do about restocking children’s sneakers?"
A long text comes back, with general advice but no clear choice.
Options: order A or order B.
Criteria: fit this month’s budget and arrive before the school year starts.
Question: which of the two meets the criteria?
Now the answer is a choice you can check.
The page presents three ways. The right one depends on the type of answer you need. Noul is the name for a yes-or-no question: instead of just “yes” or “no,” it returns the chance that the answer is yes.
Diego receives dozens of employee requests each week: schedule changes, letters, reimbursements. “Which queue should this request go to?” is Choice. “Does this request have all the documents?” is Noul. “What is the urgency, from low to high?” is Score.
Choosing the wrong format gives you an answer that’s hard to use: a score when you needed a queue, or a yes when there were several levels.
A choice alone is not enough. You also decide in advance what to do with it: when the suggestion proceeds, when AI should say “I don’t know,” and when the case goes for human review. The page cautions: confidence is not automatic authorization.
Diego set up the Choice question for the requests and added the policy.
YouContext: employee request received by HR email. Options: payroll, benefits, documents. Criterion: the queue is the one for the team that handles the request’s main topic. Request: “I need a proof of employment letter for the bank.” Respond with one option and the reason. If the request has two topics or information is missing, respond “human review”.
AIOption: documents. Reason: the request is a statement of affiliation, a matter for the documents team.
One option from the list, one reason, and a planned outcome for uncertain cases.
Stuck here? That's normalNot sure when to send something to a person? Start simple: anything with two topics or missing information goes for human review. You can adjust over time.
This is the section that makes the area trustworthy. Each number comes with what it proves and what it doesn't prove.
The public lab has 20 simulated cases: they help you learn how to formulate requests, but they don't measure quality.
A simple set of rules got 20 out of 24 fictional requests right. That's the result of the rules, not Jev.
On 19/09/2026, the first ten example kits received real responses with the expected classifications for the fictional examples. This confirms that the connection works, not that Jev gets things right.
Quality in Portuguese.
Whether the confidence the model reports matches its actual accuracy.
Day-to-day use, with independent data and comparison with a person's decision.
Sônia liked the AI's choice between requests A and B. Before using it every week, she noted: "Already observed: the choice matched mine in one case. Still needs to be measured: about ten restock orders, compared with what I would decide."
Test yourself
The public lab showed correct responses in every case you opened. Does this measure Jev's quality?
Practice now 0/3
You're ready when you have a clear question, the AI's choice checked against yours, and one line on "already observed x still needs to be measured." About 10 minutes.
Use a decision without customer names or personal data. If the AI responds with a long text instead of one option, repeat: "respond with just one of the options and the reason."
I want to turn a repetitive decision at work into a structured decision. My decision: <describe it, e.g., which team each customer email goes to> Possible options or levels: <list them> Criterion: <what makes an option the right one> Today's case: <paste a real example, without personal data> 1) Say whether the question is Choice (choose among options), Noul (chance of yes), or Score (level on a scale), and why. 2) Answer today's case with just one option and the reason. 3) Say when you should abstain and send it for human review. 4) Make two columns: what this test has already shown and what still needs to be measured before I automate it. Don't treat one example as proof of quality.
My decision: which restock order to place with the supplier.
Options: order A or order B.
Criterion: fit within this month's budget and arrive before the school year starts.
Today's case: both orders as received from the supplier, with price and delivery time.
You’ve just turned an open-ended question into a decision you can check.
Lesson cheat sheet
Jev is TypeSafe’s structured decision model. The answer is a choice, a probability, or a level, not free-form text.
Jev Decision Lab is INEMA’s educational project. The model receives context and criteria; your system is responsible for the actions.
Choice selects from explicit alternatives. Noul estimates the probability of yes. Score evaluates ordered levels, such as low, medium, and high.
The form of the question defines how to measure and which policy to apply. Uncertainty does not become automatic authorization.
The lab opens in your browser, doesn’t ask for a key, and its answers are simulated. Each case includes context, questions, criteria, an answer, an explanation, and a next step.
You can edit questions, import, export, and open a report. Changing a case invalidates the previous simulated answer.
“Jev in practice” has three tracks: Understand, Apply, and Build and evaluate. There are 12 modules, 36 lessons, and 12 labs with fictional data.
Modules 1 to 8 are conceptual; modules 9 to 12 use the terminal. The final project accepts “do not automate” as a conclusion.
A package is a kit for an area, with context, criteria, a ready-to-test example, and instructions. There are 17, covering areas from customer service and sales to meetings and curation.
Without the real lookup option, the package uses the simulated example; with it, it can consume credits. There is a Skill for Codex and Claude Code.
jev-gw sits in front of the queries, with a daily spending cap, and when something fails, it sends the case back for human review.
A simulation teaches; it doesn’t measure. The simple rules got 20 of 24 fictional requests right. That’s the rules’ result, not Jev’s.
The ten original packages worked in a real query on 19/09/2026; the seven new ones have only had controlled tests. This confirms the connection, not the quality.
Laya, a local alternative under evaluation, got 13 of 16 synthetic examples right, which doesn’t prove it is better.
Sources: JEV Area · JEV Lab · JEV Course · jev-gw Guide
Lesson 8 · INEMA Areas v6.2 · INEMA.CLUB PRO
Lesson 9 of 9 · WebMCP

You’ll be able to describe in one sentence what the WebMCP area does, run the free diagnosis of your store or company website, and choose the first fix.
More and more people are asking an AI assistant instead of searching a website. Some assistants can already open a page and fill out a form for someone. This area shows you how to get your site ready for this new visitor.
In 1 minute
An agent visiting a site today does what a person would do: looks for the field, types, clicks the button, and hopes it worked. If the layout changes, it gets lost.
WebMCP is another way. The page itself tells the agent what it can do: each action has a name, a description, and what it requests. The agent calls the right action by name. The area’s page says the technology is still experimental and available for testing in the browser.
Sônia noticed that a customer asked an assistant whether the store had a certain model. The assistant would have to open the site and search on its own.
Opens the page, looks for the search box, types the product name, and clicks the button.
If the button has moved, the answer is wrong or there’s no answer.
The page says: "consultar_estoque: tells you whether a product is in stock".
The agent calls the lookup by name. Nothing changes in the store without human confirmation.
Before studying, the area asks you to measure. WebMCP Readiness, at webmcp.inema.pro, opens your site’s address in a disposable browser and only observes. It does not trigger anything on your site.
You get an overall score and four separate scores: WebMCP, SEO, GEO, and AEO. The last two measure whether the site can appear in and be cited in AI assistant responses. Then come the blockers and a plan of up to 12 fixes in order.
A low score is normalAlmost every site starts this way because the topic is new. A low score is not your fault: it is the starting point you will compare against later.
The page lists six fixes the site owner makes before any phase. Each one is tied to an item the assessment checks. The method is short: fix it, run the assessment again, and watch the score go up.
Diego opened the list thinking about the company website, where the jobs page is. He wanted to know which item to ask the team that manages the site to address first.
The page is clear about its limits. The diagnosis shows what can be observed from the outside. It doesn’t promise that the site will rank in search results or that an AI will cite it.
And there’s one rule that applies across the whole area: AI chooses the action, but the site decides whether it can happen. A person still needs to check who can view a request and what requires confirmation.
Whether the public files exist.
Whether the title and description are filled in.
Whether actions are declared on the page.
Whether only authorized people can use the action.
Whether the action does what the description promises.
Whether repeating the action causes damage.
Test yourself
The diagnosis found an action declared for agents on your site. Does that guarantee it’s protected and works for every visitor?
Practice now 0/3
You’re ready when you’ve written down your site’s scores and chosen one of the six fixes. About 10 minutes.
The diagnosis only observes the page and doesn’t change anything on your site. Use the public address, the same one a customer would type. If your business doesn’t have a site, use a supplier’s or competitor’s site just to see the report.
Sônia ran the diagnosis on the store’s home page and wrote down the scores. The first blocker was about the public files. She chose fix 2 and noted that whoever maintains the site would check robots.txt, sitemap.xml, and llms.txt this week.
You’ve just measured your site from an agent’s point of view, and you already know the first fix to make.
Lesson cheat sheet
Without WebMCP, the agent finds fields, clicks, and interprets the screen. With WebMCP, the page offers actions with a name, description, and response.
There are two paths: an existing form gets a name and description, or the programmer registers more complete actions. It’s still technology being tested in browsers.
From the visitor’s side: agents already operate the browser, searching has become asking an assistant, and the standard is taking shape now.
From the publisher’s side: the site gets a list of actions, needs to be easy to find, and takes care of its own security.
Readiness opens the address in a disposable browser, only observes, and returns an overall score, four scores, alerts, and up to 12 prioritized fixes.
It analyzes only the page provided. It doesn’t promise a search ranking or an AI citation; the more advanced diagnostics are still planned.
The first four are about the site describing itself: being found, saying what it does, naming each action, and explaining what happens when something goes wrong.
The last four are about the site protecting itself: who confirms, who can call, where the truth lives, and how to tell if it works.
Measure, publish the three public files, fix the SEO basics, answer questions directly, show authorship, and choose a safe first action.
The page’s method: fix it, run it again, watch the score go up.
WebMCP Training offers an overview and four open phases in Portuguese: Builder, Integrator, Agent Developer, and Expert.
The phases require programming; if you don’t program, start with the overview and the diagnosis. The best first module is your own site.
Sources: WebMCP Area · WebMCP Readiness · WebMCP Training · WebMCP Builder
Lesson 9 · INEMA Areas v6.2 · INEMA.CLUB PRO