OpenCode is a free, open-source AI coding agent that runs locally on your machine and connects to over 75 different AI model providers. If you are like me you may use it as the agent/harness for local model inference.
As of today (or yesterday) OpenCode has shipped version 2.0 (or v2 depending on where you look), which comes with a few nice improvements. Of particular interest to me is the rebuilt API, background sub-agents, and enhanced plugin system (plugins are no longer considered experimental). Lets take a look at what is new in 2.0.
What’s new
Feature
What’s changed
Why it matters
Centralized background service
One persistent OpenCode service supports the terminal, desktop, web interface, and API clients.
Sessions and automation can be managed across interfaces.
Rebuilt API
Completely redesigned API with a new JavaScript client. Agents can manage sessions, worktrees, and other OpenCode operations.
Better scripting and external orchestration.
Code Mode
Agents execute JavaScript to discover, combine, and call MCP tools.
Potentially significant reductions in tool-call overhead and context consumption.
Background subagents
Agents can delegate tasks to other agents, including those running different models.
Parallel coding, testing, research, and code reviews.
Background shell commands
Long-running commands execute asynchronously without blocking conversations.
Builds and tests can run while the agent continues working.
Enhanced plugin system
More than 80 internal plugins, stable TUI plugins, and hot-reloading.
Easier customization without restarting OpenCode.
Embeddable SDK
New @opencode/sdk package exposes the engine as a library.
Build customized agents and integrations using OpenCode’s underlying infrastructure.
Personally I use switch back and forth between both OpenCode and PI for local LLM work. Both work well, and both can be a bit chatty. In particular PI, which even with Deepseek shares each and every though that is has with you – its a very chatty harness, OpenCode is much less chatty, but a bit less light weight than PI. So lets try OpenCode 2.0 and see how it performs.
Updating NPM Installed Opencode to Opencode 2.0
Note that if you installed OpenCode via npn the latest available version is 1.19.0, 2.0 is not available via npm at this time. Here are the steps to preserve your opencode configs (skills/MCPs) and seemlessly migrate to OpenCode 2.0
Back up the config. Version 1 and version 2 read the same config files, so keep a copy until 2.0 is working
cp -a ~/.config/opencode ~/.config/opencode.v1-backup
cp -a ~/.local/share/opencode ~/.local/share/opencode.v1-backup
Remove the npm opencode. This deletes only the program:
sudo npm uninstall -g --prefix /usr opencode-ai
hash -r && which opencode # should print nothing
Install 2.0 with the official install script. It installs to ~/.opencode/bin/opencode, doesn’t need sudo, and adds that folder to your PATH in ~/.bashrc
curl -fsSL https://opencode.ai/v2/install | bash
exec $SHELL
opencode --version # should report 2.x
Things to look out for:
Don’t reinstall opencode-ai from npm, or use the old install script. Both versions use the opencode command, and either one would put 1.x back or clash with 2.0.
No config changes are needed. 2.0 reads your existing opencode.json and converts the old format in memory without rewriting the file. The guide says converting the file to the new format is optional (for example, mcp. becomes mcp.servers., agent becomes agents, command becomes commands).
CLAUDE.md is no longer read. Your global AGENTS.md is still read. If any project relies on CLAUDE.md for opencode, copy that guidance into an AGENTS.md.
Skills might not be picked up. The migration guide only lists .opencode/skills/ folders inside a project; it doesn’t mention ~/.claude/skills or ~/.agents/skills. If your skills don’t appear in step 4, point the skills array in opencode.json at those two folders.
Plugins from 1.x don’t work in 2.0.
Personally I did not run into any issues, and did not need to restore my backup configs. Skills loaded, MCPs loaded, no issues thus far.
In early 2026, Meta reportedly created an internal token-spend leaderboard called “Claudeonomics,” ranking employees by how many AI tokens they consumed.
The predictable result was enormous consumption. When token usage becomes the metric, people optimize for token usage.
Meta may have been an extreme example, but the underlying idea was everywhere for a while. Across the technology industry, employees were being encouraged to experiment aggressively with AI, agents, automation, and new workflows.
Use AI.
That was often the entire strategy.
Perhaps you had a similar experience. I know I did.
Riding the Adoption Wave
I was happy to take my organization up on the offer.
These were powerful new tools, becoming more capable almost weekly. I wanted to understand them, so I dove in.
My workflows changed repeatedly. I adopted tools, abandoned others, experimented with models and agent harnesses, learned MCPs and Skills, and started integrating AI into the infrastructure and operational work I was already doing.
The objective seemed obvious:
These tools aren’t going away. Learn how to use them.
For me, that meant leaning even harder into Infrastructure-as-Code and AI-assisted operations. Services became reproducible installs committed to Git, documented, idempotent, and accompanied by health checks and operational tooling.
AI wasn’t replacing the work. It was changing how I approached the work.
And for a while, many organizations seemed to want exactly that.
The mythical “10x engineer” was back, this time carrying a token budget.
Then somebody saw the bill.
Coin a Phrase “Token-Min’ing”
Fast-forward a few months.
Token budgets were reduced. Monthly quotas appeared. Approved-model lists became smaller. Suddenly the employees who had been encouraged to integrate AI deeply into their workflows were being asked to economize.
Thus began the age of token-min’ing.
Tools and techniques appeared specifically to reduce context, shrink prompts, compress agent communication, and squeeze more work out of fewer tokens.
And that is not inherently bad.
Frontier models cost real money. Efficient use of them matters. Learning how to accomplish the same task with fewer tokens is itself an important engineering skill.
But the rapid swing from token-maxxing to token-min’ing raises a more important question:
What did organizations build while everyone was learning?
Did they develop internal AI capability?
Or did they simply develop dependency on external AI providers?
And if an organization’s AI strategy stops working the moment token budgets are reduced, was it really an AI strategy?
Adoption Was Never Supposed to Be the Destination
The early AI adoption wave should have been a discovery phase.
Give engineers access. Let them experiment. Find out what works. Learn which workflows generate real value.
Then turn those discoveries into organizational capability.
That could mean:
shared inference infrastructure;
model gateways and routing;
internal knowledge and memory systems;
RAG;
reusable Skills and MCP integrations;
standardized agent workflows;
security and secrets management;
governance and guardrails;
selectively hosted internal models;
and business-specific automation built around APIs and existing systems.
Not every company needs racks full of GPUs.
In many cases, the valuable intellectual property isn’t the model anyway. It is the workflow surrounding the model: the integrations, business logic, knowledge, guardrails, prompts, Skills, agents, and automation that allow employees to solve actual problems.
Some organizations understood this.
Others treated AI primarily as another SaaS product to provision.
That distinction matters now.
Organizations that used the experimentation period to identify useful workflows can move those capabilities into shared platforms, optimize model selection, route workloads intelligently, and decide which workloads belong on frontier models and which can run elsewhere.
Organizations that didn’t are left with a much simpler lever:
Reduce the token budget.
Employees Have Already Made a Different Decision
There is another problem.
The people who successfully incorporated AI into their work aren’t necessarily going backward.
AI subscriptions are rapidly becoming another part of the professional toolkit — not fundamentally different, from the employee’s perspective, from buying a better monitor, keyboard, IDE, or productivity application.
I see this in my own experimentation.
As I write this, I have OpenCode working through custom firmware for an open-source ESP32 watch using a locally hosted model running on an AMD GPU.
At home I experiment with local inference, different models, agent harnesses, routing, MCPs, Skills, and the infrastructure required to support them.
I don’t use personal systems for non-personal work, but they are increasingly where I continue learning.
That creates an uncomfortable problem for employers.
If employees reach their corporate AI quota and simply move some of their experimentation to personally funded tools, the organization hasn’t eliminated AI usage.
It may simply have eliminated its visibility into it.
That is a considerably worse outcome for governance, security, knowledge sharing, and organizational learning.
Once someone has experienced a meaningful productivity improvement from AI, telling them to stop using it doesn’t necessarily eliminate the demand.
It can simply make the usage invisible.
The Incentive to Hide AI Productivity
Now consider a different problem.
Suppose an employee discovers a workflow that lets them accomplish eight hours of work in six.
What incentive do they have to announce that?
If the likely response is:
“Great, here are two more hours of work,”
“Maybe we don’t need as many people,”
“Everyone should now achieve this output,”
or “This is simply the new baseline,”
then the rational behavior may be to say nothing.
The employee becomes invisibly more productive.
They continue delivering good work, but the organization never learns exactly why.
The employee keeps the workflow.
The company gets the output.
And the larger organization loses the opportunity to learn from the person who figured it out.
That is a terrible trade.
Harvest the Gain or Reinvest It
Organizations have a choice in what they do with AI-driven productivity improvements.
They can harvest the gain, or they can reinvest it.
Harvesting is easy.
An employee automates 25% of their workload, so management fills that newly available 25% with more tickets, meetings, projects, and responsibilities.
The reward for becoming more efficient is a larger workload.
There is another option.
Let some of that recovered capacity be reinvested into:
finding the next automation opportunity;
improving existing workflows;
turning personal tooling into reusable organizational tooling;
teaching coworkers;
creating shared Skills and integrations;
documenting successful patterns;
experimenting with new use cases;
and identifying where additional AI investment would produce the greatest return.
Consider a team whose job is to catch fish.
One person discovers better fishing holes, develops better techniques, and builds better lures.
Management can respond:
“You catch twice as many fish, so your quota is now twice as high.”
Or it can ask:
“Why are you catching twice as many fish, and how do we teach everyone else to do it?”
The first approach harvests the individual’s productivity.
The second creates organizational capability.
And if you consistently choose the first, don’t be surprised when your best fisherman stops telling you where the fishing holes are.ly how all organizations work.
The Employee Who Automates Their Job May Have Found Their Next Job
This may be the largest missed opportunity of all.
Some employees are naturally good at spotting repetitive work, undocumented processes, disconnected systems, and information that should flow automatically but doesn’t.
AI dramatically increases what those people can do.
If someone repeatedly automates parts of their own job, the best use of their newly available capacity may not be assigning them more of the same work.
It may be asking them to automate parts of everyone else’s.
Those employees can become force multipliers: building integrations, reusable agents, internal platforms, operational tooling, and workflows that turn individual productivity gains into organizational ones.
That requires organizations to think differently about AI productivity.
The objective shouldn’t be to maximize tokens.
It shouldn’t be to minimize tokens either.
It should be to maximize capability created per token spent.
The organizations that understand that distinction will come out of this period with more than a collection of AI subscriptions.
They’ll come out of it with people, platforms, workflows, and institutional knowledge that didn’t exist before.
And that was probably the real opportunity all along.
The tool sprawl in AI engineering has officially outrun our collective memory, at least it has mine.
Between native terminal agents, newly minted desktop clients, and entirely divergent API cost models, keeping the ecosystem straight is a full-time job.
I built this reference guide for a very simple reason: I needed a single, no-nonsense source of truth to track what tools each frontier provider actually offers right now, and exactly how running autonomous developer loops will affect my wallet.
Here is the state of the stack as I know it and use it. Sure there are plenty of options I am missing.
The Tooling Matrix: Interfaces, CLIs, and IDEs
This matrix maps out exactly where each provider expects you to interact with their models, highlighting the shift toward dedicated desktop environments and autonomous terminal agents.
None natively (Relies on community tools like Ollama or Aider)
Native integration into open-source extensions like Continue and Cline
Perplexity
Perplexity.ai (Pro search & “Pages” workspace)
Perplexity Desktop(Mac & Windows)
None (Relies on API keys for third-party scripts)
None (Primarily used as a data-grounding search API)
The Economic Matrix: Quotas, Costs, and Loop Behavior
This is the most critical matrix, IMHO. As someone who is experimenting with numerous paid frontier model services, each with a limited budge, I am not all in on any service yet, and want to maximize my low-paid token tiers.
This table explains how the subscription models and APIs.
Provider / Service
Developer Plan & Cost (USD)
IDE / CLI Billing Mechanism
Quota / Rate Limit Mechanics
The “Agentic Loop” Behavior (The Cost Trap)
GitHub Copilot
Pro: $10/mo Max: $100/mo
Flat-rate subscription for native tools.
Hybrid Metered: Unlimited standard completions + a fixed pool of premium model credits.
The Safest Route: Because it’s integrated, Microsoft absorbs a massive amount of the token cost, but heavy loop usage will hit a speed throttle unless on the Max tier.
Anthropic(Claude)
Pro: $20/mo Max 5x: $100/mo
Billed via web account or separate Pay-As-You-Go API.
5-Hour Rolling Window: Dynamic usage budget that resets every 5 hours based on server demand.
High Risk for Pro: Running Claude Code on a large infrastructure repository will hit your 5-hour limit fast. Full-time agentic workflows require switching to Claude Max or the raw API.
OpenAI(ChatGPT)
API Account (Pay-As-You-Go)
BYOK (Bring Your Own Key): Paid per token used in Cursor, Aider, etc.
Volumetric Tiers: Limits depend on lifetime account funding (Tiers 1–5), scaling from 200k to millions of tokens/min.
Predictable but Costly: Perfect for episodic troubleshooting, but an out-of-control recursive autonomous loop can easily rack up a $20–$50 bill in an afternoon.
Google(Gemini)
Code Assist Standard ~$19/mo
Flat-rate per user or metered hourly via Google Cloud.
Concurrently Throttled: Throttles users if background parallel multi-agent loops request too much compute at once.
Great for Standard Dev: Highly stable for individual coding, but hard to hook into un-vetted, third-party autonomous command-line tools.
DeepSeek
Platform API (Pay-As-You-Go)
BYOK: Funded via a pre-paid developer wallet.
Wallet Funded: Strictly bound by whatever dollar amount you load into your account.
The Economy Champion: Because of their unified architecture and heavy 90%+ prompt caching discounts, running heavy agentic loops costs literal pennies compared to western models. $10 can last a month.
Perplexity
Perplexity Pro $20/mo
Subscription includes a small monthly API credit.
Fixed Credit Ceiling: API access stops or charges your card when your small monthly search token allowance runs dry.
Not For Coding Loops: Great for pulling real-time documentation or API schemas into your agent, but financially unviable for writing or refactoring code blocks.
Understanding the Layers of Agentic LLM Tool Execution
To expand this post, it is useful to define several concepts that are now common in agentic AI systems: tools, skills, MCP servers, local execution layers, and IDE-integrated actions.
Out of the box, an LLM is primarily a reasoning and text-generation system. You can ask it questions, request explanations, have it draft a script, or ask it to review configuration, and it will respond with generated text. By itself, however, the model does not inherently have access to your operating system, local files, terminal, IDE, logs, repositories, ticketing systems, monitoring platforms, or infrastructure.
That distinction is important.
A hosted model may appear to have additional capabilities, such as reading uploaded documents, searching the web, generating files, or analyzing code, but those capabilities are usually provided by the surrounding platform, client application, or agent runtime rather than by the model alone.
This is where concepts such as tools, skills, MCP servers, and agent runtimes become important. These components extend an LLM from a passive chatbot into an interactive agentic system. The model can reason about what needs to happen, request the appropriate tool, inspect the result, and continue working through a task. The runtime around the model is responsible for exposing those tools, enforcing policy, executing approved actions, and returning results back to the model.
When discussing LLMs that can inspect logs, modify files, run scripts, query systems, or interact with development environments, it is important to separate the layers involved. These capabilities are often described broadly as “agentic AI,” but agentic behavior is usually the result of several distinct components working together.
The model provides reasoning and structured tool-call requests. The orchestration layer manages the workflow, state, prompts, and tool-calling loop. The local execution layer performs approved actions against the operating system, filesystem, terminal, repository, or other target environment. IDE-integrated actions expose workspace-specific capabilities such as file editing, diagnostics, Git state, and terminal access. Skills provide reusable task-specific instructions or workflows. MCP servers provide a standardized way to expose tools, resources, and prompts to compatible AI clients.
In other words, the LLM is tool-aware, but the surrounding runtime is tool-authoritative.
The model may decide that it needs to read a log file, edit a configuration file, run a script, or inspect a repository. However, the runtime determines which tools exist, which actions are allowed, where those actions execute, what policy controls apply, and what results are returned to the model.
The table below provides a high-level comparison of the major concepts involved in LLM-driven local execution and tool integration.
LLM Agent Execution Layers and Integration Concepts
Concept
Formal Name
What It Means
What It Controls or Provides
Example in Practice
Tool calling
Tool calling / function calling / structured tool invocation
The model’s ability to request an external action using a defined schema instead of free-form text.
Provides the structured interface between the LLM and external capabilities.
The model requests read_file(path="/var/log/app.log") or run_tests(command="pytest").
Tool
Agent tool / callable tool / local execution tool
A specific function or action that can be invoked by the agent workflow.
Provides a single capability, such as reading a file, tailing logs, running a script, or checking Git status.
Do you remember where you were on November 30th, 2022. If you were in the US (or perhaps Liberia or parts of Mexico as I have recently come to learn), you may have been sitting around the house eating leftover turkey, or a nice ham sandwich (if you were fortunate to have both available on Thanksgiving).
November 30th, 2022 was the launch date for ChatGPT.
Although it was very rough around the edges and not ready for prime-time, many immediately saw into the future. I cannot say that I did immediately, but I was out there experimenting, watching it “lie” to me. Those “lies” were quickly labeled hallucinations and sounded much cooler. Anyway the race was on apparently. Not that I was fully paying attention at the time.
Like most engineers across infrastructure, hardware, or software, I’ve spent the last four years just trying to keep my head above water. Figuring out what to learn and what to ignore has become almost as exhausting as the actual learning process. On one side, you have the performative hype from influencers desperate to prove how far ahead of the curve they are. On the other, there’s a deafening wall of noise from frontier model providers and newly christened startups, all frantically trying to dump a product before their razor-thin window of entrepreneurship slams shut.
As a traditional infra-engineer, LLMs and agentic coding have been quick to deliver value. I have never identified as a software engineer, but rather ahardware and infra-centric practitioner. I’ve spent my work-life architecting, deploying, and supporting Unix/Linux, virtualization platforms, and enabling hardware functions such as SR-IOV for Telcos across North America.
I’m the guy who knows the difference between raid 0+5 and 5+0.
Suddenly, I am now a technologist who now has the tools to quickly deliver true infrastructure as code without having to become an evangelist for any specific automation platform. Suddenly, its much easier to deploy tools, supporting services, create dashboards, and troubleshoot and resolve system/hardware issues.
Strangely I have always loved creating documentation, and have spent many years being frustrated with the lack of documentation that I have seen from others. To me, a measure of success is the fact that a solution that you built, is still relied upon once you are gone. Without proper documentation, and the ability for your successors to truly understand, operate, and enhance something that you built is dependent on great documentation. If you can not transfer the appropriate level of operational and design knowledge to those who replace you, they will replace your solution as well. With AI, everyone now has the power of documentation. “Review this repo and describe how it works, update the README.md”. It’s truly a wonderful thing.
The Micro-Eras of Agentic Coding
Having done my best to keep up via reading, experimenting, and building, I have learned quite a bit in a very short time. Those who share the same passions and beyond are often learning the same things at the same time. Separately, but also together, as they uniformly change the vernacular of agentic coding. First, we learn how to prompt from the perspective of a persona, defining outcomes. Next, we discover the need for guardrails and frameworks, especially when the word security rears its ugly head.
Nothing below is unique or original, and I am not sure that there is actually a difference between 3 & 4, or possibly the Eras are in the wrong order, but here is my table for trying to keep straight concepts and terminologies that describe those contexts
Era & Focus
The Primary Problem Solved
The Technical Stumbling Block
The AI Engineer’s Job
1. Prompt Engineering (2022-2023)
Expression: Shaping the tone, persona, and output formatting of the LLM.
Hallucinations: Cannot conjure up data or facts it wasn’t trained on.
Writing clear, contextual instructions and few-shot examples.
2. Context Engineering (2023-2024)
Information: Injecting real-time, proprietary data via RAG and Vector DBs.
Passivity: The model can read your data, but cannot act on it or use tools.
Managing token budgets, chunking data, and optimizing semantic retrieval.
3. Harness Engineering (2024-2025)
Environment: Giving the model tools, secure sandboxes, and safety guardrails.
Rigidity: Linear chains break completely when the model makes a minor mistake.
Building secure execution environments, MCP servers, and input/output parsers.
4. Loop Engineering (2025-2026)
Autonomy: Letting the system evaluate, self-correct, and iterate recursively.
Compute Cost: High token consumption due to repetitive agent cycles.
Designing state machines, testable termination conditions, and exit criteria.
“It’s all vibecoding, right”
The term “vibe-coding” was officially coined by Andrej Karpathy (former Director of AI at Tesla and co-founder of OpenAI) in a viral post on X (Twitter) on February 8, 2025.
And it’s a term that I despise, despite fully understanding how fitting that term was at the time.
Fast forward 1.5 years, and now “vibe-coding” sounds silly and very passe, as to me it implies sitting down with a chat window and an idea, and nothing more. This is what kids do in the basement to build a fun yet forgettable android game, right?
And this is not where we are today. Today we are knee-deep in learning, and imagining what the next step is in this agentic evolution.
Planning, context, guardrails, loops, governance, frameworks, and harnesses is where we are, at least mainly in theory, and sometimes in practice.
My employer recently put the kibosh on personal home lab usage.
No longer can employees who have invested time and money into building out a lab to learn and test our own products utilize their home lab to connect to any internal tool or service. You can not even access your work gmail on anything other than your company provided workstation or your monitored phone.
Which apparently means that I can no longer use my work provided Claude code account from a non-company supplied workstation, as its a company provided tool.
This was my original workflow
Now my choices are to either “Test & Deploy on Company Hardware” or utilize my own subscriptions and do my initial development on whatever workstation I happen to be in front of at the time. I chose the latter, as I want to establish my own agentic workflows that are not dependent on employer provided subscriptions, and I want to utilize my own hardware without having to deal with hardware resource scheduling.
So that takes us to where we are today.
A broken Claude Code CLI, that fails to authenticate as my initial corp provided config seems to be pervasive across multiple env vars and conf files. So lets clean that up.
First step is to remove any env vars you find in the files below