Everything is a plugin

Everything is a plugin

Published by: Digital Campaign

Updated:

Everything is a plugin

The AI industry has spent much of the past few years asking which model is best. DeepSeek Harness suggests that comparing models on their own may be the wrong comparison.

Released as a developer preview, the open-source project has already gathered more than 147,000 stars on GitHub. Its main design idea is unusually simple: everything is a plugin. The model is a plugin. So are tools, skills, sessions, storage, sandboxes, scheduling, the agent's main loop and even the user interface. DeepSeek says developers can swap or recombine these parts through settings, without changing the core Harness code.

The attention has been striking. Claims that it passed 100,000 GitHub stars in under 48 hours have spread widely, though GitHub does not keep an official history that would confirm it as the fastest-growing project on the platform. The safer thing to say is that interest has grown unusually fast.

The stars matter less than the idea: DeepSeek has made the agent harness itself a layer of technology built from swappable parts.

That matters because the centre of gravity in AI systems is starting to move. How capable the model is still matters, but more and more of what makes an agent useful, reliable and different sits in the software around the model.

The model is becoming one part of the agent

A language model on its own does surprisingly little. It takes in context and produces output. To become an agent that can get work done over time, it needs a working environment around it.

That environment may decide:

  • which tools the model can use
  • how its context is put together
  • what it remembers between interactions
  • how it reaches files and outside systems
  • when another agent is called in
  • how errors are handled
  • how permissions are enforced
  • when the system should carry on, stop or ask for help
  • what record is kept of what happened

This surrounding layer is increasingly called the agent harness. DeepSeek puts the relationship bluntly on its Harness website: "Agent = Model + Harness". It describes the model as the intelligence inside the agent, while the harness lets the model understand its surroundings, use tools and keep working in real settings. The distinction is becoming more than a technical label.

Recent research shows the same model can behave differently inside different harnesses. One 2026 study comparing set-ups for coding agents found that the choice of harness could make up to a 40-fold difference in the tokens used per task solved, even where the difference in success rates was much smaller. Other research has found big differences in completion, efficiency and how agents fail across different pairings of model and harness.

An agent is the behaviour produced by a model and the system wrapped around it, which makes the harness a core part of AI engineering.

"Everything is a plugin" opens up more of the design

Plugin designs are hardly new. Browsers, coding tools, website content systems and business applications have used add-ons for decades. What is more interesting about DeepSeek Harness is how far it takes the idea.

Its underlying framework, Cordis, treats each agent capability as a part that can be added, removed and recombined. DeepSeek's documentation says there is no special core that developers must patch to extend the system: the model adapter, tool registry, session log and agent loop are all swappable plugins themselves.

That opens up far more of the design than a normal agent framework, where the outer loop is fixed and developers mostly choose the model and tools.

In DeepSeek Harness, the system can potentially vary in several ways:

  • Model: which AI provider handles a particular task.
  • Tools: what the agent is allowed to read, query, change or run.
  • Skills: reusable behaviour or instructions for a particular field.
  • Memory and sessions: what the system keeps and how past state affects what it does next.
  • Sandbox: where actions can safely run.
  • Agent loop: how the system plans, acts, checks results and decides what to do next.
  • Scheduling and orchestration: how work is spread across time, processes or other agents.
  • Interface: how people or other systems interact with the agent.

None of these has to be permanently tied to the others. The model becomes one dependency inside a bigger assembly.

Swappable parts may matter more as agents get less predictable

Making everything swappable adds complexity. DeepSeek's answer is Cordis, the framework underneath Harness.

Cordis is built around what its authors call spatiotemporal composability. Put simply, it is designed to deal with two problems that come up in very flexible plugin systems.

The first is what happens when a part is removed. A plugin may have set up services, changed state or added dependencies. Cordis keeps track of those effects so they can be undone when the part is taken out.

The second is how parts depend on each other. Instead of assuming a fixed system built once at start-up, parts can declare what they depend on and react as things around them change. The Cordis paper calls these temporal and spatial composability. The paper is still being worked on, so treat its formal claims with that in mind.

This may sound like a technical detail, but AI agents are likely to be put together on the fly far more than normal applications are.

One workflow might need a strong reasoning model, browser access, database tools and long-term memory. Another might need a cheaper model, limited file access and no internet. A third might load a specialist checking tool for one stage of a task and remove it afterwards.

If these environments keep changing with the context, the design needs to support mixing and matching without turning every combination into a new application. The plugin becomes a boundary around each capability as well as a way to add features.

Choosing the model may happen while the agent runs

One of the biggest effects of this approach is that the model does not have to define the application any more.

Much of today's AI software still quietly follows a design centred on the model:

Choose a model, build the application around it, connect tools, then tune its behaviour.

A harness built from swappable parts allows a different order:

Define the task environment, assemble the capabilities, then pick the model that suits the task.

That is a bigger change than being able to switch from one provider to another. It means the choice of model can depend on the task.

A hard planning stage might justify an expensive top-end model. A simple data extraction task might use a smaller, cheaper one. Another workflow may need a model that handles images and audio, or one running inside a controlled environment. The application does not have to change when the model does.

Research into testing agents backs up why the combination matters. Studies increasingly argue that comparing models alone can hide real differences caused by prompts, tool set-up, memory, control loops and where the agent runs. So the useful thing to test may increasingly be the model and harness together, more than the model alone. That could change how AI systems are compared, bought and built.

The question becomes less which model is best and more which combination of model, tools, context, controls and logic works best for this task.

Our post on why the real AI race is not about models makes the same case from a business point of view.

Open source changes where companies compete

DeepSeek Harness is released under the MIT licence, and its repository includes the code for the whole harness, which goes well beyond a connector for DeepSeek's models. DeepSeek also documents other agent tools that can use its model APIs, which shows it is not presenting the model and harness as products that must go together.

A closed agent product can stand out through the experience it builds around its model: memory, tools, coding workflow, orchestration, context management and interface. Those features can make it costly to switch away, even if the models underneath become interchangeable. An open harness built from swappable parts challenges that link.

If developers can keep their tools, workflows, sessions and orchestration while swapping the model, competition moves up a level from the model. If they can swap the agent loop as well, it moves up again.

The most valuable part may end up being whichever part of the system is hardest to replace. That might be:

  • your own context and data
  • skills for a specific field
  • trusted places to run code
  • links into workflows
  • testing systems
  • security controls
  • memory built up over time
  • specialist orchestration
  • the user experience

The model is still essential. It just stops owning the whole stack.

Plugins bring governance problems as well as freedom

There is an obvious counter-argument. A design where everything can be swapped is also one where everything can change. That means a lot to govern.

A model plugin can change how the model behaves. A tool plugin can widen what the agent can reach. A memory plugin can change what information is kept. An agent loop plugin can change when actions happen. A sandbox plugin can change the limits on where code runs.

So swappable parts make it more important to track where each part came from, manage dependencies, test and enforce policy. Our post on AgentOps covers the operating discipline this calls for.

DeepSeek has made traceability another key feature of Harness. It says the system records what the model receives in a session log that can only be added to, never edited. That log includes system prompts, reasoning, tool calls and results, scheduling of sub-agents and any context added along the way. Its Trajectory interface then uses that record to inspect, replay, search, resume and branch off sessions. If parts can change on their own, companies need to know which combination produced which behaviour.

A useful record of live use may eventually need to show more than the model version:

Model + prompt + tools + skills + memory + policies + loop + plugin versions + where it ran

So watching an agent means watching its whole set-up. Without that, flexibility can turn into unpredictability.

The harness could become the new application layer

There is a bigger possibility behind all this. Today's AI application stack is often shown as a set of layers: model, information search, tools, orchestration, application and interface. But increasingly capable harnesses start to absorb many of those layers.

DeepSeek Harness already covers models, tool registries, skills, sessions, storage, sandboxes, loops, scheduling and the interface. Its standard set-up provides a coding agent with planning, goals, sub-agents and workflows, while other modes change how those capabilities are offered and coordinated.

At some point the word harness may start to undersell what this layer is becoming. It begins to look more like a runtime for agents: the environment they run in.

This runtime does more than supply intelligence. It decides how intelligence enters a software environment and what happens next.

That matches a wider trend in agent research. Recent work increasingly treats harnesses as systems responsible for planning, memory, tool use, running actions, checking results, state and recovery, more than as thin wrappers around a model.

If that continues, AI design may start to split into three broad layers:

  • Intelligence: models provide reasoning, writing and judgement.
  • Runtime: harnesses provide context, tools, state, loops, permissions, running actions and monitoring.
  • Environment: applications, data, APIs, users and outside systems make up the world the agent acts in.

So the key boundary in the design may be moving away from the individual model and towards the runtime that sits between intelligence and action.

The most valuable AI engineering may happen outside the model

None of this means models stop mattering. Better reasoning, longer context, stronger handling of images and audio, and lower running costs will keep changing what agents can do. Research also shows cases where swapping the model inside the same harness makes a big difference to performance. The mistake would be to swap an obsession with models for an obsession with harnesses. What is changing is how the two relate.

As base models get more capable and several providers can do the same task, the work that sets products apart shifts more and more to how intelligence is put together into a working system:

  • Which context reaches the model?
  • Which tools can it use?
  • How does it know whether an action worked?
  • What happens after a failure?
  • What is kept?
  • What gets checked?
  • Who can change the runtime?
  • How can the resulting behaviour be rebuilt?

Those are harness questions, and DeepSeek's contribution is to turn almost all of them into parts you can configure, instead of fixed assumptions.

Everything is a plugin

DeepSeek Harness is still clearly labelled a developer preview. Its maintainers warn that changes that break compatibility should be expected, so it is far too early to treat the current version as a settled blueprint for agents in live use. Its importance lies elsewhere.

"Everything is a plugin" turns the agent from a mostly fixed piece of software around a chosen model into an assembly of swappable capabilities.

Developers can experiment with how the agent remembers, acts, checks, keeps state, coordinates and recovers, as well as with which model does the thinking.

The bigger shift is from competing on models to competing on the systems that make models useful. If everything is a plugin, the product is the whole assembly, and the model is one part of it.


Sources and References