Step 06 · Foundations Easy · 12 min

🤖Installing the agent (very early)

Claude Code or OpenCode, in five minutes. The trick: install it now, so it configures the rest of the machine for you.

Here’s the least intuitive secret of this whole journey: you install the code agent before everything else.

Most tutorials have you configure the machine for three hours, network, firewall, services, then install the AI at the end, like a reward. We do the opposite. You set up the agent now, while the system is still bare, and it’s the agent that will help you hook up Tailscale, Cloudflare, Ollama and the whole shebang. You go from “I’m typing commands I don’t understand” to “I describe what I want, I review, I approve.”

Claude Code or OpenCode: which one?

Both are excellent command-line code agents. They read your project, write files, run commands, and loop until it works. These are the two this guide follows at parity : but they’re not the only ones. The difference between them fits in one sentence:

Claude Code : Anthropic’s agent. You plug into the Claude models (the best on the market for code in 2026). Ultra-simple setup, top reliability on long tasks. Paid (subscription or API).
OpenCode : the open-source agent. Same spirit, but you choose your engine: Claude, GPT, or a local model via Ollama. Perfect if you want 100% local or to juggle providers.

And if you want to explore more widely, the landscape is rich in 2026, they all work on the same principle (read, write, run, loop):

Antigravity CLI (agy command) : Google’s new command-line agent, plugged into the Gemini models. It replaces Gemini CLI, whose consumer service Google shut down on June 18, 2026 (free, Pro and Ultra accounts were moved over automatically; only enterprise Gemini Code Assist licenses stay on the old tool). Written in Go, it orchestrates several subagents in the background. Installs via a script, no longer through npm : curl -fsSL https://antigravity.google/cli/install.sh | bash.
Codex CLI : OpenAI’s agent, backed by the GPT models.
Aider : a much-loved open-source agent, built around git (every change = a clean commit), compatible with just about any model, local ones included.
Pi : the minimalist alternative to OpenCode. Same open-source world, opposite philosophy: a bare-bones core you extend yourself. See the callout right below.
Cline / Roo Code : agents that live inside VS Code rather than in the terminal, if you’d rather stay in your editor.
Cursor, Windsurf : full code editors, built around AI, for anyone who wants an all-in-one experience.
Orca : not one more agent, but an environment to run them in (an “ADE”, Agent Development Environment). See the callout right below.

Orca: running several agents at once

Orca (open-source, MIT license) is a desktop app designed as a workshop for agents. Instead of one agent per terminal, you launch several in parallel, each in its own isolated git worktree (a separate copy of your project). While one agent refactors, another writes tests, a third fixes a bug, without stepping on each other, and you compare their outputs side by side.

It bundles a terminal, a browser (to point at a UI element and feed it to the agent), GitHub/Linear integration, and above all SSH worktrees: the app runs on your Mac or laptop, but the agents execute on your remote mini-PC. With its mobile companion, you keep an eye on them from your phone. You bring your own subscriptions (Claude Code, Codex, OpenCode…): Orca only orchestrates them. The right move the moment “one agent at a time” becomes a constraint.

Pi: the minimalist alternative to OpenCode

Pi (by Earendil, MIT license) plays in exactly the same arena as OpenCode: an open-source terminal code agent that reads, writes, runs and loops, with any provider (around fifteen: Anthropic, OpenAI, Google, Azure, Bedrock, Mistral, Groq…) or a local model. The difference is philosophical, and the right image is VS Code versus Neovim. OpenCode ships batteries included: MCP, subagents, plan mode, permission popups, it’s all there from install. Pi makes the opposite bet, “adapt Pi to your workflows, not the other way around”: a core trimmed to four tools (read, write, edit via Unix diff/patch, bash) and a system prompt of barely a few tokens, on the idea that recent models are already trained to code and that over-specifying them only holds them back. Everything else (MCP, subagents, plan mode, to-dos…) is deliberately left out: you add it as TypeScript extensions, only if you want it.

In practice, who picks what? Go with OpenCode if you want everything out of the box with no tinkering, more providers (75+ vs ~15) and a unified-key plan (Zen/Go). Go with Pi if you enjoy shaping your own tool, working on a modest machine, or running local models, where it shines especially on Mac (MLX and GGUF formats). No free tier: you bring your own key. Nice touches: tree-structured sessions (branching history, HTML export, share via gist), mid-session model switching (/model or Ctrl+L), and four operating modes (TUI, print/JSON output, RPC protocol, SDK to embed it). Install: npm install -g --ignore-scripts @earendil-works/pi-coding-agent (also via curl, pnpm or bun).

What about the other agents and models? (cloud and local)

Claude Code and OpenCode aren’t alone, and above all: an agent and the model that makes it think are two distinct things.

On the agent side, there are other tools in the same spirit (Google’s Antigravity CLI, the former Gemini CLI, OpenAI’s Codex, Cursor, Aider…). The Claude Code / OpenCode duo stays my pick for this guide, but the principles you learn here carry over to all of them.
On the cloud models side, Claude isn’t the only option: OpenAI (GPT), Google (Gemini), xAI (Grok), Microsoft (via Azure/Copilot), Mistral and others offer very solid models. Claude remains, in early 2026, the reference for agentic coding, but it’s a landscape that moves fast.
On the local side, any of these compatible agents can run on your own models via Ollama, with no cloud at all.

The real strength of an open agent like OpenCode is exactly that: you plug in whatever provider you want, cloud or local, and you switch whenever you feel like it. We dig into the choice of engine in Choosing and sizing your model.

One key, every model: unified APIs

When an open agent like OpenCode asks you “which provider?”, you could create an account with each vendor (Anthropic, OpenAI, Google…), juggle five keys, five bills, five quotas. Or plug in a unified API: a single service sitting in front of dozens of models, exposing one key, one bill, one format. You switch models without switching accounts, and you pay for everything in one place.

OpenRouter : the best known. A single key gives access to hundreds of models (Claude, GPT, Gemini, Grok, Llama, Qwen, DeepSeek…), with automatic routing to the cheapest or fastest provider, fallback if one goes down, and a dashboard that tracks spend down to the token. Pay-as-you-go, a thin markup over wholesale price. Ideal for comparing ten models on the same task without ten sign-ups.
OpenCode Zen : the OpenCode team’s own gateway: a set of models curated and benchmarked for agentic coding (40+ options, from frontier to small-and-fast, including a few free ones). Fewer choices than OpenRouter, but each one is vetted to behave well inside an agent (not just in a chat). Pay-as-you-go (wholesale price + processing fees), with configurable auto-reload and monthly cap. To connect: /connect in OpenCode → “OpenCode Zen” → paste the key.
OpenCode Go : the same idea, but on a flat plan: roughly $5 for the first month then $10/month, for access to low-cost coding models without counting tokens. The smart pick if you code every day and prefer a fixed amount to a variable bill.

How to actually navigate this

No need to adopt it all on day one. A few markers that save time:

Start simple. Your main vendor’s direct subscription (a Claude plan for Claude Code, say) already covers 90% of needs. The unified API is the next step, for when you want to mix models.
One unified key turns OpenCode into a Swiss Army knife: a local model for routine work, a cloud frontier model for the heavy lifting, all from the same config and the same bill. That’s where it really shines.
Set a spending limit the moment you sign up (monthly cap, sensible auto-reload). In practice you’ll fire up a big model “just to see” pretty fast: the guardrail saves you the end-of-month surprise.
Flat plans (OpenCode Go) win for steady use; pay-as-you-go (OpenRouter, Zen) wins for spiky use or exploration. Start usage-based, switch to a flat plan once your bill becomes predictable.
Treat the key as a secret: never in plaintext in the code, never on GitHub. More on that in Securing access.
Read the data policy. On a gateway, some models (often the free ones) reserve the right to reuse your prompts for training. OpenRouter lets you filter that in its settings; for sensitive code, demand “no-logging” models or stay local.
Fully free exists too: a local model via Ollama goes through no paid API at all. A unified gateway only matters for the cloud, or for a cloud + local mix.

The common prerequisite: Node and a clean terminal

Both agents run on Node.js. We install it cleanly with nvm (version manager) rather than with the system package, to avoid permission headaches.

# Install nvm (Node version manager)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
# Reload your shell (or close/reopen the terminal)
source ~/.bashrc
# Install the latest Node LTS
nvm install --lts
node -v   # should show v22.x or newer

Install and launch

The CLI installs with npm, globally:

npm install -g @anthropic-ai/claude-code

Launch it from any folder:

claude

On first launch, it opens your browser to log you in (Anthropic account, Pro/Max subscription, or API key). Once authenticated, you’re inside the agent. Type a request in plain language and watch it work.

The CLI installs with a script (or via npm):

curl -fsSL https://opencode.ai/install | bash
# alternative: npm install -g opencode-ai

Launch it from any folder:

opencode

On first launch, type /login to choose and connect a provider: Anthropic, OpenRouter, or a local model if you’ve already followed the Ollama step. You can switch models at any time.

Your first real move: have it configure the machine

This is where the magic happens. Rather than chaining system commands yourself, you ask. Here’s a first concrete mission, to copy almost verbatim once into the agent:

Describe the goal, not the commands

In the agent, write something like:

“We’re on a brand-new Ubuntu 24.04. I want you to help me finish the basic config: automatic security updates, a ufw firewall that lets only SSH through, and zram for swap. Explain each step before running it, and don’t run anything with sudo without showing me the command first.”

Review the plan before approving

The agent will propose a plan and commands. Read them. That’s the heart of the craft: you no longer type, you review. If a command looks fishy, ask “why that one?” before accepting.

Let it execute, keep your hand on the wheel

You approve step by step. On an error, the agent reads the message, understands, and fixes it. You’ve just configured your machine by chatting.

Lay the foundations of memory right away

Before you leave, create the file the agent will read at every session: a CLAUDE.md (Claude Code) or AGENTS.md (OpenCode) at the root of your project. Two lines are enough to start, we dig into the topic in Memory files.

cd ~/mon-projet
cat > CLAUDE.md <<'EOF'
# Machine context
- Mini-PC Ubuntu 24.04, use: personal dev workshop.
- Always show sudo commands before running them.
- No secret in plain text in the code.
EOF