The series · 7 episodes
Building intelligence
How machines that learn work, from the first neuron to today's agents. No hype.
In preparationSystems thinking applied to AI agents
Take the stack apart. Learn to govern it.
A method that goes beyond coding.
Coding agents become a training ground for systems thinking. A way of reasoning that runs from software to networks, all the way to automation.
Free7 modules69 lessons8 open-access lessons
The author
Giuseppe CiternaAI Network Engineer · CCIE #10503
The main agents explained in the course
Claude Code
Cursor
Codex
Cline
Copilot
Antigravity
The course
What you’ll be able to do
Across the seven modules you learn to recognize the components, understand how they work together and choose where to step in. Three skills you put to the test with practical cases and interactive tools.
Analyze
Understand how the system is built
Model, provider, API, agent, surface, IDE and environment. You tell their roles apart, understand how they connect and know where to look when something doesn’t work.
Configure
Choose a configuration that fits the work
You follow the path of requests, data and commands. You check which components can work together, what access is needed and where operations run.
Govern
Decide what the agent can do
You tell the instructions given to the model apart from the controls the system enforces. You set permissions and checks, organize the work of one or more agents and decide when they must ask for your input.
The syllabus
The seven modules
- M0Getting oriented6 lessons
- M1How an agentic stack works10 lessons
- M2Following connections, access, and data9 lessons
- M3Governing behavior and automation22 lessons
- M4Coworkers, integrated platforms and agentic engineering13 lessons
- M5The 42 worked cases8 lessons
- M6Certification and closing1 lesson
How to start
Eight open-access lessons
You can read them without an account. To continue, create a free account: once you confirm your email, the whole course opens.
The tools and the Diagnostic are also available without an account.
The interactive tools
Put what you learn into practice
Create a configuration, compare the alternatives and find out why a combination works or gets stuck.
The final test
The certification
At the end of the course you can put what you’ve learned to the test: 30 questions across nine areas of competence. If you pass, you get a credential in your name.
You decide whether to make it publicly verifiable.
Human + agent
When doing things becomes easy, what do we need to learn?
Agents make many tasks easier to carry out. What must we keep learning and be able to do, as we hand a growing share of the work to AI?
- LearnWhich knowledge and skills to keep developing.
- MeasureThe gap between what we get with AI and what we actually know.
- GovernWhat to delegate to AI and which skills to keep in people.
Build the first map
Start from a concrete case and learn to tell apart who proposes, who coordinates and who executes.
Going further
Follow me on LinkedIn →
Other courses and learning paths
Explore the paths dedicated to networks, models and artificial intelligence systems.
The twin path
The network that thinks: Journey to AgenticOps
The same method applied to networks: how the infrastructure becomes a nervous system that thinks, decides and acts. It's the path that anticipated AgenticOps a year ago. v1 is available.
v1 availableThe handbook
AI Stack
The model Open Systems Interconnection (OSI) applied to artificial intelligence systems: ten blocks and three questions for analyzing larger systems.
In preparationThe essay
The crisis of knowledge in the age of agents
What happens to expertise when agents do the work in our place.
In preparation
I publish new courses and learning paths on LinkedIn. Follow me to find out about upcoming releases.
We compare products using the same criteria, regardless of the provider. The course includes the verification dates. In the 17 October 2026 update, we revised 24 lessons. You’ll find the summary in Updates.
By Giuseppe Citerna.
By Giuseppe Citerna.
Updates
v3.4October 2026
v3.3September 2026
v3.2August 2026
v3.1August 2026
v3.0August 2026
v2.0August 2026
v1.0June 2026
Keeping the course up to date
The course gives you a method for understanding and governing agents. When the way a product works changes, we update the relevant explanations and exercises. For up-to-date procedures, follow the links to the official documentation.
Latest update25 October 2026 · v3.4
What’s new in this release
- The full course, straight awayNo more waiting for approval: create your free account, confirm your email, and every lesson, the practice mode and the certification open up.
- From the cloud to your PCA new optional deep dive at the end of Module 2, chapter 3: how a cloud session uses your computer through Claude Desktop, and why that differs from Remote Control. Six diagrams, and for every claim you can tell whether it is documented, observed in a test or inferred.
- Remote Control on a serverIn Module 2: on a machine you reach over SSH, the Remote Control server starts inside tmux or screen, and no inbound ports need to be open.
- Remote ControlSimula now accepts Claude Code steered from the browser on a server of yours reached over SSH too, and Antigravity steered from the browser on your computer.
- Cline and CursorCline’s Cloud Agents take the model only from Cline’s own routes: Simula no longer accepts your key there. Simula explains better where Cursor’s web agent runs on a machine of yours, and the Matrix notes Bedrock in the Cursor CLI and the plans that exclude your own key.
- Configura and the MatrixConfigura suggests Codex from the desktop app with an external service too, and Copilot with Claude and Gemini too, and says that in Kilo’s Cloud Agent the container is paid to Kilo. In the Matrix Copilot also works over SSH and on your own runners; you sign in to Kiro with an AWS Builder ID, and cloud sessions also start from the IDE and the CLI.
- One sourceEach agent's surfaces and environments are written once, in a capability register: Simulate, Configure and the Matrix's Surface and Environment columns read them from there, and automated checks make sure they stay consistent.
- Level of evidenceWhen Simulate allows a combination that the official sources don't fully document, it adds a note: the verdict stays, but you know how far it is verified.
- Checked against the sourcesRe-checked against the official documentation: extensions over SSH, Cursor over SSH and with your own key, and steering from the browser a session that runs on your computer (Remote Control, Remote Connections). In the Matrix, Cline, Kilo and OpenCode now list all their surfaces.
- Context and memoryA new lesson in M3 explains what the agent has to work with: project instructions, memory, compaction, checkpoints and hand-offs between sessions.
- SandboxThe permissions lab has a new part on the sandbox boundary. In M3 you see how an authorized command can run other code; in M4 an exercise separates a valid proposal from a verified change.
- ToolsThe certification page, Simulate, Configure and the Matrix have a new design, easier to read on a phone too.
- ClaudeChat and Cowork are coming together in a single Claude experience. On Pro and Max, new Cowork tasks run in the cloud.
- Claude CodeProjects coordinate multiple work threads in the cloud or on your computer. Dispatch remains an optional comparison for those who already use it.
- Apps and environmentsWith Desktop on 3P and environments you manage yourself, we distinguish where the agent works from where the model runs.
- PermissionsWe explain what modes, permission rules, hooks and Mods control, and what their limits are.
- Codex and GLMZ.AI documents a Responses endpoint for using GLM in local Codex without adding a gateway.
- Work and ReplitWork Cloud can use the connected computer for local operations. The Replit section now covers Free, Power and Max modes.
What changes for you
24lessons revised, in Italian and English
17assessment questions updated
6Matrix rows updated
+8structural combinations added to Simulate
- New and revised diagrams showing where the session, the tools and the model run.
- You can follow the session lab without Dispatch. It remains an optional comparison for those who already have access to it.
- Simulate and Configure also include GLM in local Codex through Z.AI’s Responses endpoint.
History
October 2026 update
We revised 24 lessons to make clearer where agents work, how they reach tools and how their actions are controlled. The Matrix, Simulate, Configure and 17 check questions were updated, with texts and diagrams realigned in Italian and English.
The same course, in English
Agenticodice speaks two languages inside the same application. Italian remains the source and English is derived from it: same lessons, same tools, same identifiers, the same Matrix. What changes is the address you arrive by, not the course.
- Portalbilingual
One application serves both languages:
/is Italian,/en/is English. Deep links point to the same identifiers in both. - Coursetranslated
The 67 lessons, the two Off the path deep dives and the certification exist in English, with a technical glossary fixed once and respected everywhere.
- Toolstranslated
The Matrix, Simulate, Configure, The Engine and the 42 worked cases run in English on the same data and the same rules as the Italian.
- Servicetranslated
What surrounds the course is in both languages too: portal pages, email messages, privacy notice, cookie policy and terms of service.
- Methodunchanged
No lesson was rewritten for the occasion. The method, the module weights and the certification bank remain those of v3.2.
In detail
English is not a copy to be kept aligned by hand: it is born from the Italian at build time, and the key of every phrase is the Italian phrase itself. When an Italian line changes, its translation becomes stale and the check names it before publication, instead of letting it grow old in silence.
Two measures watch the English edition from opposite sides. Coverage asks that every translation actually reach the screen — 10,288 units out of 10,288, with no differences in structure or markup. The residue check asks the opposite, that no unwanted Italian is left in the English; what stays Italian on purpose is declared one by one, with the reason written beside it.
Two things stay in Italian, both by choice. The "Read in Italian" link at the top of the service pages, which exists precisely to take you back. And the lab commands, which are code: translating the expected output of a command would mean changing the rule that authorises it at the same time, and the rule would stop matching.
Update v3.3.2 · September 2026Three fixes to the English edition: the reserved lessons reached account holders in Italian, the language switcher was missing from the course header, and internal links took you back to Italian instead of keeping you where you were.
The facts, re-verified one by one
The course doesn't age in silence. A maintenance procedure compares every product rule against the official sources, and when the documentation isn't enough, we open the application and look. This version collects the first complete round of those checks: no new chapters, many sentences that now say what the product really does.
- Antigravitycorrected
You can bring a guest agent into Antigravity, but with its own account: using the Antigravity login from third-party software violates Google's terms of use. The warning now opens the lesson.
- Clineexpanded
There are four ways to give Cline a model, not two: your own key, a local runtime, the Cline account and the ClinePass subscription. In all of them, the model stays third-party.
- Kilo Codecorrected
The real name is back, and with it the real surfaces: besides the extension there are the JetBrains plugin, the command line, Slack, the mobile app and the cloud agent.
- Kironew
AWS's agent enters the course as an example of the rule on surfaces: five different doors, one agent underneath. It also has a row of its own in the Matrix.
- Cursorcorrected
The Agent's catalog isn't a closed list of four names: today it also hosts third-party models. The rule doesn't change — the catalog decides, not your key.
- Sourcesreviewed
Base URL and memory in Claude Code, Copilot, Lovable and ChatGPT Work: pages moved, one name changed, one sentence turned on its head.
In detail
Google explicitly forbids using third-party software to access Antigravity with the Antigravity login, and the stated penalty is account suspension. The course showed those cases without a warning: now the warning comes first, with the legal way next to it — a Vertex or AI Studio API key.
Cursor's catalog was described as four fixed names. Listing a catalog is a losing battle, because it changes every month: the sentence was rewritten around the thing that doesn't age, namely that Cursor decides the list and that a personal key opens the chat at most, never the Agent.
The Simulator learned a better answer too. When you tried pairing GLM with the Cursor Agent it replied "this model isn't in the catalog": today that's no longer true. The combination is still wrong, but for the right reason — the model is indeed listed, but you reach it with the Cursor plan, not with your key.
**Update v3.2.1 · September 2026** Full language revision of the course and of the two off-the-path deep dives: 95 prose edits, with no changes to content, features or architecture.Full language revision of the course and of the two off-the-path deep dives: 95 prose edits, with no changes to content, features or architecture.
Access, with one tap
The course stays free: what changes is how you unlock all of it. The request for full access reaches the owner, who answers with one tap, and three messages guide you through the process from start to finish.
- Accessnew
Full access opens on the owner's approval, with no manual steps and no waiting in the dark.
- Approvalnew
The owner decides straight from the message they receive: the answer is confirmed and recorded in a single step.
- Messagespolished
The emails along the way — request, approval, welcome — have been rewritten and made safe against anything users enter.
In detail
The approval is a single, indivisible step: either the decision is recorded in full, or it isn't recorded at all. That guarantee matters when two requests arrive at the same instant.
The course becomes a portal
The course stays the same, free and mostly readable without signing up. Around it grows an environment that remembers: an account with your progress saved, a starting point captured by the Diagnostic, certification with a verifiable credential, and the documents that say how data is handled.
- Accountnew
Progress and current lesson saved on any device; eight lessons, spread across the course, stay open-access; the others open with the free account.
- Diagnosticnew
Twelve questions, only once: your starting point, tied to you and not to a browser.
- Credentialnew
Certification issues a credential in your name, with public verification that you can enable yourself.
- Transparencynew
Privacy notice, cookie policy and terms of service describe the system as it is, generated from the same inventory that governs the code.
In detail
Eight lessons, spread across the course, stay free and need no registration. The others open with the free account, which does one thing only: remember where you are, on whatever device you pick up again.
The documents on privacy, cookies and terms aren't boilerplate: they come from the same inventory the code uses to describe the system, so they say what the system really does.
Learning to govern the system
The first version taught you to recognize the seven fundamental pieces of an agentic stack. The second keeps that map, but builds a complete path around it for learning to use it, verify it and carry it over to new systems.
- Pathrewritten
Seven modules across concepts, labs and guided cases, each closed by a checkpoint.
- Toolsunified
Simulate, Configure, Engine and Matrix become four complementary ways of using the same model.
- Reasoningnew
Forty-two cases let you apply the method beyond the examples explained directly in the course.
- Certificationexpanded
Thirty questions, nine areas and three levels of complexity, with a final profile and a review of your answers.
- Deep divesnew
"Human + agent" and "A course that lives as code" extend the course to the relationship between human expertise and AI, and to the building of the learning system itself.
In detail
The path expands from four stages to seven modules and sixty-seven lessons, and each module closes with a checkpoint that brings together what you've just learned.
The four tools stop being separate exercises: Simulate composes a stack piece by piece, Configure starts from a goal, the Engine shows the rules that decide, the Matrix compares real configurations side by side.
The seven pieces of coding agents
The first public version introduces the original mental model: Model → Provider → API → Agent → Surface → IDE → Environment, with a guided explanation, interactive stack composition and a final test.
Permanent reference
The Matrix
The Matrix puts the ways of using agents side by side. You don’t have to memorize it: use it to compare two configurations or to figure out where to look when something doesn’t add up.
How to read it
Each row tells you which surface you command the agent from, where it works, how you get in, who pays, which models you can use and the limit to keep in mind. When a configuration can reach the model through different paths, open “Technical details”.
Yes Yes, with limits No The “Different model / service?” column tells you whether you can connect a model or service other than the default one yourself.
19 configurations · 7 with technical details · 2 cross-cutting components
| Agent | Surfacewhere you command it from | Environmentwhere the agent and the tools run, and where the files live | How you get in | Who pays | Models | Different model / service?can you connect it yourself? | Limit to keep in mind |
|---|---|---|---|---|---|---|---|
| Claude / Anthropic | |||||||
| Claude Code | CLI | LocalSSHCI | Claude loginAPI keyCloud identity on enterprise configurations | Claude planChosen provider or serviceCloud account on enterprise configurationsNo API consumption with a local model | ClaudeOther compatible modelsLocal models through a compatible runner | Yes, with limits | To use a different model, the service must be compatible with what Claude Code requires; changing the address alone isn't enough. |
Technical detailsAnthropic pathClaude Code→Anthropic→Claude
API: Anthropic Messages
Compatible pathClaude Code→compatible provider or gateway→model
must accept the format required by Claude Code.
Local modelClaude Code→compatible local runner→local model
the runner must expose a compatible connection.
Enterprise cloudClaude Code→supported enterprise cloud service→Claude
identity, configuration and billing follow the chosen cloud service.
|
|||||||
| Claude Code | IDE extensionVS CodeCursorAntigravity | LocalSSHwith Remote-SSH the extension runs on the host (manifest); the rest is not documented | Claude loginAPI keyCloud identity on enterprise configurations | Claude planChosen provider or serviceCloud account on enterprise configurations | ClaudeOther compatible models | Yes, with limits | If you open Claude Code inside Cursor, VS Code or Antigravity, the agent is still Claude Code: it doesn't automatically use the accounts, models and rules of the IDE hosting it. |
| Claude Code | Claude desktop app | LocalCloudSSH | Claude loginDesktop on 3P: access configured for the provider | Claude planDesktop on 3P: costs of the configured provider | Claude | Yes, with limits | The standard version uses the Claude login. A gateway in Anthropic Messages format is configured in the app (Developer → Configure Third-Party Inference) or set by the administrator; the app doesn't read ANTHROPIC_BASE_URL. With the gateway active there are no Anthropic cloud environments and no Remote Control. |
Technical detailsDesktop standardClaude Desktop→Anthropic→Claude
You sign in with your Claude account. The app doesn’t automatically pick up the ANTHROPIC_API_KEY set in the terminal.
Desktop on 3PClaude Desktop on 3P→Bedrock · Google Cloud Agent Platform · Foundry · gateway→Claude
Desktop on 3P is a separate distribution. You configure the service that runs the Claude models and its access method. The CLI configuration isn’t carried over automatically. Check which features and cloud sessions are available in this distribution. This support doesn’t extend to the regular web surfaces and doesn’t imply that you can use models other than Claude.
|
|||||||
| Claude Code | WebCan be started from the CLICan be started from the app | Anthropic cloudOr your own computer or a server of yours, with Remote Control: the browser steers a session that runs there. | Claude login | Claude plan | Claude | No | Starting it from the CLI or the app doesn't make the work local: agent, tools and copy of the files stay in the cloud. |
| Codex / OpenAI | |||||||
| Codex | CLI | LocalSSHCI | ChatGPT loginOpenAI API keyCredential of the chosen service | ChatGPT planOpenAI API platformChosen provider or gatewayNo API consumption with a local model | GPTResponses-compatible modelsCompatible local models | Yes, with limits | A custom service must speak OpenAI Responses. If it only offers Chat Completions, you need a translator. |
Technical detailsOpenAI pathCodex→OpenAI→GPT
expected format: OpenAI Responses.
Compatible providerCodex→Responses-compatible provider→model
GatewayCodex→gateway that exposes Responses→provider→model
Local modelCodex→Responses-compatible local runner→local model
|
|||||||
| Codex | IDE extensionVS CodeCursorAntigravity | LocalSSHwith Remote-SSH the extension runs on the host (manifest); the rest is not documented | ChatGPT loginOpenAI API keyCredential of the chosen service | ChatGPT planOpenAI API platformChosen provider or gatewayNo API consumption with a local model | GPTResponses-compatible modelsCompatible local models | Yes, with limits | If you open Codex inside Cursor, VS Code or Antigravity, the agent is still Codex: it doesn't automatically use the accounts, models and rules of the IDE hosting it. |
| Codex | ChatGPT desktop app | Localalso in a separate worktree of the projectSSHproject on a remote host | ChatGPT loginOpenAI API keyCredential of the chosen service | ChatGPT planOpenAI API platformChosen provider or gatewayNo API consumption with a local model | GPTResponses-compatible modelsCompatible local models | Yes, with limits | The app is the agent's surface: the work stays where the project is, on your PC or on a connected SSH host. A custom service must be compatible with OpenAI Responses. |
| Codex cloud | WebCan be started from the appCan be started from the CLICan be started from the IDE | OpenAI cloud | ChatGPT login | ChatGPT planChatGPT credits | GPT managed by OpenAI | No | In the cloud task you can't connect your own API key or a personal endpoint. Starting it from the IDE or the CLI doesn't move the work to your PC. |
| Google / Antigravity | |||||||
| Antigravity agents | Antigravity IDEIDE with an editorAntigravity Appdesktop, without an editorExtension for VS CodeFrom the browser, with Remote Control | Localin the configuration documented by the course | Google login | Free use with limitsGoogle AI plan | GeminiThird-party models present in the Google catalog | No | You can't freely add your own key to the managed catalog. If you host another agent in the IDE, that agent keeps its own models, accounts and rules — and always signs in with its own account: using third-party software with the Antigravity login violates Google's Terms of Service. |
| Antigravity | CLIFrom the browser, with Remote Control | LocalSSHRemote cloud environments | Google loginChiave Gemini API, solo per Gemini | Free use with limitsGoogle AI planWith a Gemini API key you pay the provider for usage | GeminiThird-party models present in the Google catalog | Yes, with limits | With the Gemini API key you can use Gemini. For models from other vendors, the access provided by the Google catalog applies. |
| Cursor | |||||||
| Cursor Agent | Cursor IDE | LocalSSHwith Remote SSH the files live on the host; the AI runs on your PC and on Cursor's servers | Cursor loginPersonal API key for the supported chat modelsnot on the Free and Plus plans | Cursor plan / creditsChosen provider for the calls that use your keyon Teams and Enterprise Cursor adds a per-token fee even with your own key | ClaudeGPTGeminiGrokComposerand other third-party models in the catalogOther personal models where supportedGrok and Composer are Cursor's models: on Free and Plus, only these | Yes, with limits | You can use your own API key for the supported chat models. The agent remains Cursor Agent, and some features use other paths. For calls made with your key, check the provider’s data retention terms: Cursor’s Zero Data Retention doesn’t automatically extend to that connection. |
Technical detailsCursor catalogCursor Agent→Cursor backend→catalog model
for the managed catalog, don't attribute an upstream executor if the sources don't document it.
With your own API keyCursor Agent→Cursor backend→chosen provider→model
Even with a personal key, the request goes through Cursor’s backend, which prepares the prompt. The key identifies your access to the provider and the calls are billed to that account; the agent’s work stays managed by Cursor. Also check the provider’s data retention terms: a compatible key isn’t enough to guarantee Zero Data Retention.
|
|||||||
| Cursor Agent | CLI | LocalSSHinferred: the CLI installs on Linux, use over SSH is not documented | Cursor login | Cursor plan / creditsAWS for Bedrock requests | ClaudeGPTGeminiGrokComposerand other third-party models in the catalog | Yes, with limits | From the CLI the only documented route with your own credentials is AWS Bedrock (the /bedrock command, with an explicit Bedrock model ID): the request still goes through Cursor and AWS pays for it. OpenAI, Anthropic or Google keys in the CLI aren't documented. |
| Cursor cloud agent | WebCan be started from the IDECan be started from the CLI | Cursor cloudOr a machine you manage: it hosts files and commands; Cursor keeps managing the agent loop and the model calls. | Cursor loginwith a plan that includes cloud agents (not Free or Plus) | Cursor plan / credits | ClaudeGPTGeminiGrokComposerand other third-party models in the catalog | No | Starting it from the IDE or the CLI doesn't make the work local; for cloud tasks the documentation describes Cursor's catalog and doesn't provide for a provider's key. |
| AWS / Kiro | |||||||
| Kiro | IDECLIWebMobile to follow and approve | Local on IDE and CLIthe CLI also on a server over SSH, with code-based loginKiro cloud on Web and Mobilecloud sessions can also be started from the IDE and the CLI, on paid plans | GitHub, Google or AWS Builder ID logincompanies: IAM Identity Center or a corporate identity providerAPI key only for CI, on paid plans | Kiro plan / credits | ClaudeGPTOpen-weightAutomatic selection | No | From every surface you use Kiro's managed catalog: no key of your own for the models, and the month's credits don't carry over. Starting a cloud session from the IDE or the CLI doesn't make the work local: the copy on your PC isn't uploaded. |
| GitHub Copilot | |||||||
| GitHub Copilot Agent | VS Code | LocalSSHthe Agents window connects to a remote machine: the agent works with the files and tools there | GitHub loginPersonal API key where supportedLocal model where supported | Copilot creditsChosen provider on BYOK callsHardware and upkeep for the local model | GPTClaudeGeminiand others in the catalog, depending on plan and clientSupported personal modelsSupported local models | Yes, with limits | Your key can be used in Copilot Chat and in the supported local agentic workflows, but inline completions and some other actions follow separate paths. |
Technical detailsCopilot catalogCopilot Agent→GitHub Copilot services→catalog model
With your own API keyCopilot Agent→chosen provider→model
Local modelCopilot Agent→local runner→local model
a personal key doesn't mean every call in the Copilot experience uses that model.
|
|||||||
| Copilot cloud agent | WebCan be started from the IDE, GitHub CLI, API and integrations (Slack, Teams, Jira, Linear…) | GitHub Actions cloudalso on larger runners or your own (self-hosted): the machine can be yours, orchestration stays with GitHub | GitHub login | Copilot AI creditsGitHub Actions minutes | GPTClaudeGeminiand others in the catalog; Auto where you don't pick the model | No | Starting it from the IDE doesn't make the work local, and in cloud tasks you can't connect your own API key or a personal model. |
| Multi-provider | |||||||
| OpenCode | Main CLIDesktop appIDE extensionVS CodeCursorWebweb interface of the opencode server | LocalSSHCLI on an SSH host and extension with Remote-SSH: not documented; web on a server of yours reachable on the network | Provider's API keyLogin where supportedOpenCode Zen account, if usedNo credential for a local model | Chosen providerChosen gateway or serviceOpenCode Zen, if usedNo API consumption with a local model | ClaudeGPTGeminiGLMOpen modelsOther models from the supported providers | Yes | Each connection accepts its own type of access: login, subscription and API key aren't automatically interchangeable. |
Technical detailsDirect providerOpenCode→provider→model
GatewayOpenCode→gateway→provider→model
Local modelOpenCode→local runner→local model
API and format depend on the chosen connection.
|
|||||||
| Cline | IDE extensionVS CodeCursorAntigravityCLIDesktop appWeb | LocalSSHextension with Remote-SSH (not documented); desktop app connected to a remote hostCloud ClineCloud Agents, from the browser only and through Cline's own routes | Provider's API keyGateway's API keyCline Provider account, if usedCline account with ClinePass subscriptionNo credential for a local model | Chosen providerChosen gatewayCline ProviderFixed monthly ClinePass quota, no per-token costNo API consumption with a local model | ClaudeGPTGeminiGLMOpen modelsOther supported models | Yes | The chosen model and the connection used must properly support the tools Cline needs. |
Technical detailsDirect providerCline→provider→model
GatewayCline→gateway / OpenRouter→provider→model
Managed pathCline→Cline Provider→catalog model
Local modelCline→local runner→local model
|
|||||||
| Kilo | IDE extensionVS CodeCursorJetBrainsother compatible editorsCLIDesktop appWebCloud Agent; or Remote Connections to the CLI on your computer | LocalSSHfrom the CLI onlyCloud KiloCloud Agent, from the browser or with kilo cloud from the CLI | Provider's API keyKilo account on the GatewayAPI key registered in the Kilo Gateway | Provider on the direct connectionKilo when you use the Kilo balanceUpstream provider when you use your own key in the Gateway | Model chosen directlyModels available through Kilo Gateway | Yes | With Kilo Gateway the bill changes with the configuration: with the balance you pay Kilo; with your own key registered in the Gateway you pay the upstream provider. In the Cloud Agent, even with your own key, container time is always paid from the Kilo balance. |
Technical detailsDirect providerKilo→provider→model
Kilo Gateway with balanceKilo→Kilo Gateway→upstream provider→model
the user pays Kilo.
Kilo Gateway with BYOKKilo→Kilo Gateway→upstream provider→model
the user pays the provider of their own key.
|
|||||||
IN THE TECHNICAL PATH
Cross-cutting components
Runners and gateways appear in the technical details because they can sit between the agent and the model, but they aren't agents. We keep them separate from the main Matrix so as not to confuse different roles.
| Component | What it does | Where it enters the path | Access and cost | Limit to keep in mind |
|---|---|---|---|---|
| Ollama / LM Studiolocal runners | Runs a model on the machine you choose and exposes a local API connection.The available format depends on the runner and the configuration. | Agent → local runner → local model | Normally no login or keyNo API consumptionHardware, memory, power and upkeep remain | The runner runs the model; on its own it doesn’t act on the project’s files. A compatible API may support only part of the original format. Check which features are available and verify that the model can use the tools the agent requires. |
| Gateways / adaptersLiteLLM · OpenRouter · proxies | Receives the agent's request and routes it; when needed it can normalize or translate the format. | Agent → gateway → provider → model | Gateway key, provider key, or bothThe gateway or the provider bills you, depending on the configuration | It isn't the model and doesn't guarantee full compatibility: tool use, streaming and other capabilities may change. |
The Matrix compares configurations. If you want to try a combination, use ; if you start from your constraints, use ; if you want to see why a combination passes or gets blocked, open the .
A course that lives as code
An ordinary course can explain to you how a coding agent works. Here we tried to go one step further: to represent its structure inside the course as well. Components, relationships, constraints, cases, and sources don't live only in the pages; part of that knowledge is organized so that software can use it.
That's what lets Simulate, Configure, the Matrix, the Engine, the 42 worked cases, and the certification look at the same system from different perspectives.
Under the course · a structure the software can read
MODEL→Claude
PROVIDER→Anthropic
API→Anthropic API
AGENT→Claude Code
SURFACE→CLI
IDE→VS Code
ENVIRONMENTlocal
The course doesn't just store the names of the pieces: it also represents how they connect, which conditions have to hold, and which sources that information rests on.
Computable model of the course
the part of the knowledge that can be represented in structured form
DATA · components and properties
RELATIONSHIPS · who is connected to whom
RULES · verifiable conditions
SOURCES · evidence and date
ENGINEWhen a relationship can be expressed as a rule, the software can apply it to a concrete stack.
chosen stack → rule → consequenceWhat "as-code" means
It doesn't mean a lesson is written in HTML or that there's JavaScript behind it: that only describes the medium through which the page is published. The interesting step happens when part of what the course teaches is also represented as data, relationships, rules, and sources — that is, in a form the software can read, check, and reuse.
You can think of it as a kind of conceptual digital twin of the coding agent, as long as the metaphor is taken in the right sense: it's not a real-time synchronized copy of Claude Code, Codex, or Cursor, but a general model of the anatomy we're learning to read.
Two models, two audiences
For the software
Computable model of the course
data, relationships, rules, and sources
- represents the pieces and their properties;
- connects what depends on what;
- expresses some conditions in verifiable form.
For you
The student's method
the grid you use to read a system
components → connections → flows
→ constraints → effects
→ constraints → effects
- works even without the course in front of you;
- stays valid on tools you've never seen.
They aren't two competing models. The first lets the course build and check some experiences; the second is the grid with which you learn to read those experiences and, later on, systems the course has never encountered.
How the course uses that model
The same representation is queried in six different ways. They aren't six copies of the same application: what changes is the question they ask and the moment of learning in which they're needed.
| Tool | What it does with the model |
|---|---|
| LESSONSbuild the map | Here you learn to tell the pieces apart and to follow the relationships between them. It's the representation you'll use when you move on to the tools. |
| SIMULATEputs it to the test | You compose a concrete stack. The system builds the state of the combination and, where an executable rule exists, can check whether that step holds. |
| CONFIGUREstarts from the constraints | Here the question flips. You don't ask whether a configuration works: you describe what you need and look for the possibilities that respect those conditions. |
| MATRIXputs the stacks on the same table | It uses common dimensions to make different configurations comparable: agent, model, route, environment, access, costs, and limits stay visible in the same frame. |
| 42 WORKED CASESmake the why visible | The code builds the card from the structured case. Then the explanation walks through the case and shows which mental steps lead to the verdict. |
| CERTIFICATIONtakes the help away | In the end it doesn't matter whether you recognize a screen from the course. What matters is whether you can use the same grid in front of a less familiar situation. |
They're different ways of turning one and the same representation of the domain into a learning experience.
What happens when you use it?
So far we've looked at the architecture from above; now let's follow it from the learner's point of view. The same model passes through three different moments: first you can try a configuration, then you have to learn to explain its behavior, and finally you have to manage to transfer the method when the help disappears.
1 · Try
In Simulate, the model can answer you
YOU COMPOSE
Claude→Anthropic→API→Claude Code→CLI→VS Code→local
↓
MODEL + ENGINEchecks the combination against the available rules
↓
✓ PASS
The route doesn't speak the format the agent expects.
When you choose the components, the course builds the state of the stack. Where that relationship has been turned into an executable rule, the Engine can apply it and return a consequence: it isn't looking for a pre-written sentence, it's using the model to respond to the configuration you built.
Simulate answers one question: "does this combination hold?"
2 · Understand
The verdict alone doesn't teach enough
THE SAME KIND OF CASE
Claude→Anthropic→API from another family→Claude Code
1
COMPONENTSWhat am I looking at?
2
CONNECTIONSWho talks to whom?
3
FLOWSWhat passes through?
4
CONSTRAINTSWhich condition decides?
5
EFFECTSWhat changes?
✓
VERDICTIt stops at the constraint: the route speaks a format the agent doesn't expect.
→
TAKEAWAYBefore blaming the pieces, check what format the route speaks.
Here the goal changes. Simulate can tell you that a combination stops; the case has to teach you how you could have figured it out yourself. The code knows the structured case and builds the card, but the explanation remains a teaching object: it decides what to observe, which constraint to highlight, and which principle to carry to the next case.
Simulate makes the behavior visible. The 42 cases make the reasoning visible.
3 · Transfer
At some point the help has to disappear
A CASE NEVER SEEN BEFORE
X→Y→Z→?
components → connections → flows → constraints → effects
You decide
In the certification the software builds the test and collects the result, but the educational point is to see whether you can use the method without having Simulate's answer or a case's walkthrough in front of you. At that point the model must no longer live only in the page.
The question isn't "do you remember this case?". It's "can you still read the system?"
Try→Understand→Transfer
··
What the code does, what stays with the author
Naturally, not the whole course becomes code. The software can read data, apply some rules, build views, find dependencies, and run checks. What remains editorial is the choice of what to teach, the way to explain it, the design of the cases, and the final judgment on a change.
As-code doesn't mean "everything automatic". It means making explicit what can be structured, connected, and checked.
And when the world changes?
There's another advantage in having a model instead of a simple collection of pages: the world the course describes changes. Imagine a vendor modifies an access route; that fact could be used by a rule, by Simulate, by Configure, by the Matrix, by one of the 42 cases, by the certification, or by an explanation.
In a traditional document
where did I write this?
In a connected system
what depends on this?
This is where the maintenance pipeline comes from: an update is treated almost like a network change, with verification of the source, impact analysis, modification, checks, and only at the end the release.
Change pipeline
keyboard · ← → · space
READY · 10 steps
CHANGE
VERIFY
IMPACT
PATCH
TEST
HUMAN
RELEASE
POST
rule
Simulate
Configure
Matrix
42 cases
certification
lessons
What's happening
One change, ten steps
Here a course update is treated like a network change: you can walk through it step by step, go back, and stop where you need to.
change log · press Next or ▶ Play
A skill can describe the maintenance runbook; an agent can carry out many of its operations; the pipeline produces checks and evidence. Editorial approval stays human.
What remains, in the end
So an "as-code" course isn't simply a course written with code. The difference is that part of the knowledge has an explicit structure: it can be queried by Simulate, compared in the Matrix, used to build cases, and checked when the course changes.
The code, however, doesn't replace the teaching work. The Engine makes executable what can become a rule; the 42 cases go the opposite way, starting from a behavior and turning it into reasoning that can be understood and reused. And the certification closes the loop: at some point that structure must not live only in the course.
This page's rule
The code keeps the model consistent.
The cases teach you to reason about the model.
In the end, that model has to live in the student's head.
The cases teach you to reason about the model.
In the end, that model has to live in the student's head.
We've seen how part of the knowledge can become a model the software can use. But when work and skills also start to move toward agents, a bigger question arises: what do we want to keep building in the human being?
Simulate · try it
Create a stack
Choose one component for each level. If the combination meets the rules, you move on to the next check; otherwise you see which condition isn’t satisfied.
First time here?
How to read the result
What you practice here composing a stack component by component and explaining why a combination is valid or not.
This simulation checks the structural compatibility of the seven components. When you complete a coherent structure, a separate panel checks the documented operational route or points out the data still to be specified: gateway, credential and billing aren't inferred from product names alone. In the Engine view you can follow the structural checks, step by step.
This view represents the stack described by the configuration. In distributed systems, coordination, tools and resources can sit in different environments: check their connections separately. A structurally compatible result doesn’t certify permissions, privacy, availability or the terms of use of the route.
Configure · your stack
Let’s build your stack
Here you apply the consultant's method: first gather the requirements, then make a reasoned proposal.
The requirementseight questions, the way you'd ask a client
The combinationsyou check which ones meet the constraints and what changes when you alter one
The proposalthree reasoned stacks, with an essential plan and the official documentation
How to read the proposals
You can repeat the analysis with different requirements.
The Engine generates and verifies the structural combinations; each proposal then completes the access path with separate data —
This view represents the stack described by the configuration. In distributed systems, coordination, tools and resources can sit in different environments: check their connections separately. A structurally compatible result doesn’t certify permissions, privacy, availability or the terms of use of the route.
The rules in execution
It isn't a list.
It's an engine.
This view shows how the structural rules evaluate every combination of the seven components, record the result and produce the counts used by the lab.
The results don't come from a static list. On every load the page generates the combinations of the seven components, applies the structural rules and updates the counts. Credential, gateway, entitlement and billing belong to the access path instead: they are evaluated separately when the configuration specifies it.
—possible structural combinations
→
—hold up to the rules
→
—distinct structural families
→
3yours, from the eight answers in Configure
1
the evaluation · selects seven components and checks them, one check at a time
inside the engine · one attempt at a time
→on record
2
the log · every attempt goes on record — where it fails and why
the log · real attempts
3
the technical view · the code the page actually runs
the technical view · functions and calls in execution
the
buildAllStacks()calls
the
compat(step, id)reads the state · selanswers
the verdict
{ ok, why }The panel shows the engine's canonical rules, the same ones the page is running, rendered directly from the data that defines them. During the animation the rule that is deciding lights up, so you can link each step of the diagram to the corresponding rule.
running
Every line of the log corresponds to a real evaluation. The combination is checked component by component and, if it isn't valid, the log names the rule that isn't satisfied. The numbers are computed: if the component catalog changes, the counts change too.