Claude → Codex area · model-agnostic workspace

Don't migrate your brain. Separate the brain from the model.

Only CLAUDE.md and AGENTS.md are tied to the provider. Everything else you have built up — context, rules, decisions, tasks, skills, handoffs and memory — is portable Markdown. Once that material lives in a portable layer inside the project, Claude Code, Codex CLI, Gemini or a local model in a container become nothing more than executors: switching models becomes switching an edge, not the center. This area brings together the thesis, the method, the 3-track course, the script kit and the mega-prompts that make it happen in practice.

The course is open and available in English; the kit and the prompts are open and written in Portuguese. The live session has a date to be announced in the community.

01 · What is changing

Lock-in isn't in the model. It's in what you left inside the runtime.

The course starts from a simple discomfort: anyone who has used a coding assistant for a few months has piled up instructions, memory, skills, hooks and thousands of sessions in a format only that runtime reads. When a better, cheaper or mandatory executor shows up, the bill arrives. And it isn't a technical bill: it's knowledge stuck in the wrong place.

Change 1

Lock-in is invisible until switching day

CLAUDE.md, native memory and JSONL sessions look like part of the work. They aren't: they are the storage of the work. The content is durable, the format is disposable — and mixing the two is what stalls a migration.

Change 2

Same knowledge, any model

Rules, accepted decisions, tasks with a definition of done and handoffs are text. Written into files with an owner and a reading order, any agent that reads Markdown picks up where the other one stopped — including a local model running in a container.

Change 3

Less dependency, more control

You stop managing prompts and start managing context, state, tools, processes and validation. The model becomes a reversible choice: if it gets worse, gets pricier or disappears, the center stays in your repository.

Before · the brain inside the runtime

A giant CLAUDE.md · native memory · JSONL sessions · hand-copied skills · harness hooks

It works very well — as long as you only use that one runtime. Switching means rebuilding, and rebuilding means losing the decisions nobody wrote down.

After · the brain in the project

AGENTS.md · context/overview.md · context/decisions/ · tasks/current.md · handoffs/latest.md · skills with a single source

The names are a convention: no runtime loads these folders on its own. What makes them get read is the reading order at the top of AGENTS.md. That's why it works on any executor.

Models change. Your structure stays.

The thesis of the course, in five words.

02 · The method

Audit → Adapt → Prove → Handoff. In that order, and never implementing before auditing.

The kit's mega-prompts start in MODE: audit on purpose: first analyze, plan and simulate; only then implement. The rule that closes the method is the hardest one to accept — a file existing is not proof; the agent having read and used it is.

Diagnose→Audit→Adapt→Install the core→Port skills→Prove→Handoff
Step 1

Audit

What exists today, without touching anything?

A read-only inventory of both runtimes: skills, commands, subagents, hooks and MCP. Each skill is classified as reusable, adapter, native or unresolved.

Step 2

Adapt

What is portable and what is residue?

CLAUDE.md splits in two: portable rules go to AGENTS.md; whatever depends on a plugin, a hook or a Claude menu stays in the specific file, which merely imports the portable part.

Step 3

Prove

Can a fresh session carry on?

Five continuity questions — goal and definition of done, one rule with its source file, the last decision, the next action, conflicts — asked in each runtime.

Step 4

Handoff

What does the next session need to know?

Decisions, open items, next steps and paths in a Markdown file. The following session, in any runtime, reads it before acting. Handoff before closing, always.

What the portable core is

Seven places, each with an owner and an update rule. This is what the kit installs without overwriting anything that already exists in the project.

The files

Where each thing lives

  • AGENTS.md — stable rules and reading order
  • context/overview.md — verified facts, with source and date
  • context/current-state.md — what works and what is pending
  • context/sources.md — where each piece of information comes from
  • context/decisions/ — one accepted decision per file
  • tasks/current.md — goal, owner, definition of done, next action
  • handoffs/latest.md — the continuation for the next session
The types of information

Owners, not folders

  • Fact — verified, with origin and date
  • Preference — how you want it done
  • Hypothesis — not confirmed yet
  • Decision — accepted, with scope and status
  • Provenance beats timestamp: nothing is deleted, you use superseded_by
  • Indexes can be rebuilt from the sources
  • Secrets and raw material stay outside the repository
Why this is more than tidiness. Mixing a fact with a hypothesis, or a decision with a preference, is what makes the agent repeat an old mistake and contradict what was already settled. The owner and the date are what let you promote a piece of information from raw memory to approved context — with your approval, never automatically.

03 · Migrate or stay agnostic

Three levels. The first one solves today; the third one solves the next switches too.

The course splits the decision into levels of effort, not into opinions. Migrating means reaching level 1 or 2. Staying agnostic is level 3 — and it is the only one that survives the next model switch, which will happen again.

Level 1 · one click

Import in the app

The shortest path when a ready-made import exists. Fast, and limited to what the other side accepts — the Codex CLI, for example, has no native import.

Level 2 · one command

Migrate with the kit

Run the agente-claude-codex scripts: audit, adapt instructions, install the core, port skills and prove it in a fresh session in both runtimes.

Level 3 · lasting

The portable personal layer

Reorganize the work so that knowledge lives in the project and the runtime is interchangeable. More work once; no migration afterwards.

Migrate now if…

  • You need to use the other runtime this week, for cost, access or policy reasons.
  • Your setup is concentrated in a few projects and a few skills.
  • Most of your skills are plain Markdown (reusable in the audit).
  • You want results before reorganizing how you work.

Stay agnostic if…

  • You have already switched tools once and don't want to do it all again.
  • You want to use two or more executors at the same time, including a local one.
  • Many skills depend on MCP or on harness hooks (adapter and native).
  • There is client work, where scope and isolation have to be explicit.
What migrating changesInstructions and skills move to the other runtime. The way you work stays the same.
What staying agnostic changesThe project gains a portable core, a handoff cycle and skills with a single source.
What doesn't changeYou still pick the executor per task. Agnostic doesn't mean abandoning Claude.
The cost of doing nothingKnowledge keeps piling up in a format only one runtime reads.
True for bothAudit before implement, and proof by reading in a fresh session.

There is no final state. Every provider change improves one executor and breaks another: closed models may do without skills that a local model requires, and a hook that exists in one harness doesn't exist in the other. That's why the method ends in maintenance — watching the drift between copies and logging every failure in one line, with the smallest possible fix.

Want to use both together? Once the brain is separated from the model, you can use Claude and Codex on the same project — one does the work, the other reviews it. The Codex + Claude area brings together the six levels of the Use Both kit, who does what and every INEMA course and project on the two tools.

Open the Codex + Claude area →

04 · The course

Three tracks: understand, do, and apply it to real projects.

The course Claude → Codex: migrate or stay agnostic is open, with versions in English, Portuguese and Spanish. According to its own curriculum, it has 3 tracks, 18 modules and 108 topics; each module has six topics of about half an hour. Audience: people who already use Claude Code or Codex and want to use both — or not be locked into either.

Track 1 · Fundamentals

Why and what

It defines every term on first appearance: model, runtime, harness, skill, MCP, hook, handoff. This is the track that answers "why isn't copying CLAUDE.md enough".

  • 1.1Why separate the brain from the model
  • 1.2The vocabulary: runtime, harness, skill, MCP, hook, handoff
  • 1.3The three levels of migration
  • 1.4Anatomy of a portable workspace
  • 1.5Owners of the information: fact, preference, hypothesis, decision
  • 1.6Audit before implement
Start with track 1 →
Track 2 · Hands-on

The kit, command by command

Practice with agente-claude-codex: every module has at least one example you can copy and run, with the real commands from the scripts.

  • 2.1Environment diagnosis: doctor.sh and audit.sh
  • 2.2CLAUDE.md → AGENTS.md: portable on one side, residue on the other
  • 2.3Install the portable core without overwriting
  • 2.4Canonical skills with polyskill: one source, N runtimes
  • 2.5Readback: prove it in a fresh session, in both runtimes
  • 2.6Handoff and prime: the daily cycle
See track 2 →
Track 3 · Projects

Six projects on a real system

Each project has a goal, steps with commands, acceptance criteria and risks, using the diagnosis of a real machine as the case study.

  • 3.1Migrate your first real project
  • 3.2MCP and hooks between Claude and Codex
  • 3.3Curated memory: the agent proposes, you approve
  • 3.4A third executor: a local model in a container
  • 3.5Client workspace: Venn, scope and canaries
  • 3.6The mindset: all of this is iterative
See track 3 →

Also in Portuguese and Spanish. The PT and ES versions are complete mirrors, with their own assets and progress tracked separately per language. Every page has the PT / EN / ES selector at the top.

Open the course →

05 · The agente-claude-codex kit

Command line and Markdown. No interface, no bulk copying, nothing deleted.

The kit is bash plus Markdown files, and it can be used in three ways: the scripts, the mega-prompts (to run the migration by talking to an agent) and the template of the portable core, which you can copy into any project without running a single script.

Steps 0 and 1

doctor.sh and audit.sh

doctor.sh answers "is my environment ready?" — each item comes out as ok, warning or missing, with the command to fix it. audit.sh writes a read-only report with the inventory of both runtimes and the classification of every skill.

Steps 2 and 3

adapt-instructions.sh and init-core.sh

The first one reads the project's CLAUDE.md and writes two proposals next to it, without overwriting. The second copies the portable core, listing what it created and what it kept. There is also faxina.sh, which classifies a long CLAUDE.md section by section.

Step 4

sync-skills.sh with polyskill

One canonical source per skill, copies generated per runtime, and a drift command that tells you, per destination, whether it is identical or has diverged. Installing makes a backup alongside before overwriting.

Step 5

readback-test.sh

It opens a fresh session in each runtime inside the project, asks the five continuity questions and saves the raw answer. Approval is yours, by reading the text: do the answers cite the right files, and does the next action match the task?

Daily cycle

session-handoff and prime

The two canonical skills that ship with the kit: one writes the handoff at the end of the session, the other reads AGENTS.md, context/, tasks/ and handoffs/ before acting and returns a briefing with the sources. Together, they close the cycle.

Maintenance

drift-report.sh and promover-memoria.sh

A weekly report on divergence between the skill copies and the global AGENTS.md; and a flow in which the agent proposes facts with source and date out of raw memory, and only what you approve enters the context.

What has actually been run on this machine (2026-09-13 and 2026-09-16). According to the kit's README: doctor.sh passed with two warnings; the audit found 89 skills existing only in Claude — 71 reusable, 15 adapter, 2 native and 1 without a SKILL.md; adapting the global CLAUDE.md separated 71 portable lines from 7 lines of residue; the core installed in an isolated clone passed the check; readback passed in both runtimes; the canonical skills ended up installed in four destinations with zero drift; and a fresh Codex session, after prime, pointed out three real contradictions between the handoff and the task. These are execution records in the repository itself, not a benchmark and not a measure of model performance.

Would you rather do it by talking? Mega-prompts A (migrate an existing Claude setup) and B (build a portable workspace, with personal and client add-ons) are available as copyable text in the repository. Keep MODE: audit on the first pass, read the plan the agent returns and only then run it in implementation mode.

See the prompts → (in Portuguese)

06 · What INEMA already has on the topic

Course, kit, prompts and the full map. All open.

On the company side. If your question isn't which executor to use, but how to manage agents inside a company — roles, authority levels, cost per result and evaluation —, the AI Management area carries that conversation on.

Open the AI Management area → (in Portuguese)

07 · Get started now

The best first step is a project of your own, in audit mode.

Pick a project you know well, run the diagnosis and read the audit before changing a single file. In one session you already know what is portable, what needs an adapter and what depends on a hook. The course and the kit are open; the live session about migrating or staying agnostic has a date to be announced in the community.

Course · free and open

Take the course

Three tracks: understand why to separate the brain from the model, run the kit command by command, and apply it to six projects with acceptance criteria.

  • Fundamentals: vocabulary, three levels, portable core
  • Hands-on: doctor, audit, adapt, polyskill, readback
  • Projects: first real project, MCP and hooks, curated memory
Open the course →
Premium community · live event

INEMA.VIP

Where the live session "migrate or stay agnostic" will be announced, with the real system on screen: audit, adapt, prove, handoff. And where you can discuss your own migration with people who have already done theirs.

  • The date of the live session is announced here first
  • Supporting material from the trainings
  • People to review your AGENTS.md and your handoff
Join the INEMA.VIP community →
Kit · open source

Run the kit today

Clone it, run doctor.sh, read the audit. Nothing in ~/.claude or ~/.codex is bulk-copied or deleted, and installing a skill makes a backup alongside.

  • Scripts for diagnosis, adaptation, proof and drift
  • Portable core template for any project
  • Mega-prompts A and B, if you'd rather talk it through
Open the kit guide → (in Portuguese)

Not sure where to start? Talk to us on Telegram.