Your AI can write code. Who controls what it can do?
Agent harnesses, skills, and sandboxes help organize AI work. Understand what each layer does and how to evaluate agents in your repository.
Voices depend on your browser and device; some require internet access. Code blocks are not read aloud.
Estimated reading time: 10 minutes. Sources checked on October 26, 2026.
You ask for a small fix. The agent opens the repository, introduces an abstraction, adds a dependency, touches a file that had been minding its own business, and wraps up with the confidence of someone who has just rescued software engineering.
Then you open the diff.
The original issue may actually be fixed. But now you have a second assignment: figuring out how a form correction turned into a renovation of the entire house.
This is an illustrative scenario, but it introduces a question I find more useful than “Which AI writes the best code?”: What environment are we giving the AI to work in, and how are we checking the result?
When I look at integrations like those I develop at Oombe, I think about API contracts, business rules, intermediate states, and consequences. Generating code is one part of the job. Delivering a change that respects all those constraints takes a method. That is where agent harnesses, runtimes, skills, and sandboxes enter the discussion.
Four names, four responsibilities
These terms often appear together, but they help answer different questions. I use the following practical distinction to organize the discussion:
| Layer | Question it helps answer |
|---|---|
| Model | How should the task be interpreted, and what comes next? |
| Harness | How should tools, context, state, and continuity be coordinated? |
| Skill | Which reusable procedure should guide this task? |
| Sandbox and policies | Which resources can the execution actually access? |
Products can combine these functions. This table is therefore a way to examine an architecture, rather than a universal classification of tools.
The Agent Skills specification defines a directory containing a SKILL.md file and optional resources. Descriptions, instructions, and files can be loaded progressively. That structure makes knowledge available when needed without placing an entire manual in the initial context.
A skill can explain how to review an integration. The execution environment must provide ways to inspect files, run checks, and present evidence. Each component has its own job.
The conversation has matured, but it did not begin in 2026
Anthropic introduced Agent Skills in October 2025, and its announcement records the publication of the open standard in December that year. There was already a concrete effort to turn procedures into reusable resources.
In 2026, the discussion includes examples we can inspect, compare, and try. I find that more interesting than announcing a revolution whenever a new name appears.
I would also avoid declaring “the end of wrappers.” A single model call may be enough for a well-defined task. Anthropic's guidance on building agents recommends starting simple and adding complexity when it improves the outcome. A predictable workflow remains a valid engineering choice.
If your application classifies text and returns one field, a team of agents might introduce more maintenance than value. It is worth asking which decision actually needs autonomy.
Useful skills capture knowledge about the work
Imagine a skill for reviewing changes to a marketplace integration. I would start with the questions an experienced integrator would ask: Does the change respect the API contract? How does it identify the correct account? What happens if the response is incomplete? Does an existing dependency already solve this need?
Next, I would define the evidence expected: cases examined, checks performed, limitations found, and decisions requiring business context. An instruction such as “produce professional code” offers little help with those choices.
The value lies in making the procedure explicit and reviewable. If the team discovers a new error condition, it can update the skill and assess whether the next execution handles it better. Learning becomes concrete maintenance work.
Matt Pocock publishes a collection of small, composable skills addressing requirements, feedback, and architecture. Addy Osmani organizes practices across the development lifecycle, including verification, review, and delivery. These are authored collections with their own choices, useful for study and adaptation.
I would resist installing an entire collection on impulse. I would pick a recurring problem, read the relevant files, and observe the effect. The procedure should help the team make better decisions, including when the right decision is to keep an implementation simple.
An instruction does not grant or revoke permission
Writing “do not read secrets” in a file provides guidance. Restricting access to those secrets requires a configuration that keeps working when the agent makes a mistake.
The NVIDIA OpenShell architecture illustrates this separation: a trusted supervisor applies policies to resources and connections outside the agent's environment. The project documents network mediation and credential delivery only to approved destinations.
The practical question is what remains accessible after a bad instruction. If the process can read every user directory, the sentence “work only on this project” does not provide a filesystem permission limited to that directory.
I would build the environment around what is necessary: the project's code, development tools, and test data. I would add specific access as the task requires it. Production credentials deserve a separate decision; they should not become available through an accidental inheritance from the terminal.
I would also distinguish the ability to propose a change from the ability to apply it to an external service. Reviewing a file and publishing a change have different effects. The system should represent that difference in a verifiable way.
This concern connects with what I previously discussed about fragile security behind an attractive interface: visual confidence and operational confidence need different evidence.
DeepSeek Harness: an interesting architecture with an explicit notice
The official DeepSeek Harness uses a plugin architecture built on Cordis. Its README describes it as a developer preview subject to breaking changes. It is a real DeepSeek AI project, rather than merely a nickname used by the community.
The critical qualification appears in SAFETY.md: the project states that it has not undergone a security audit and should not be treated as secure or production-ready. It also explains that its controls do not guarantee isolation.
I would take that notice seriously when choosing an evaluation environment. A disposable lab lets us learn about the architecture without turning enthusiasm into an operational dependency. A demonstration's result should be interpreted within the conditions in which it was produced.
The word “harness” describes a function in a system. To decide where to use a particular product, we still need to examine its maturity, permissions, maintenance, and documented limits.
The work needs to survive the end of a conversation
There is another, less cinematic dimension: continuity. A task may span sessions, interruptions, or changes of context. The next agent needs to understand what has happened and what remains unfinished.
In Effective harnesses for long-running agents, published in November 2025, Anthropic describes a combination of environment preparation, incremental progress, Git history, and progress records. The goal is to help later sessions resume verifiable work.
In practice, I would request a short record answering four questions: What was the task? Which decisions were made? Which checks passed? What should happen next? An enormous document may simply move the confusion into another file.
I would also treat “complete” as a state supported by evidence. If the expected behavior depends on an interface interaction, compiling the project does not automatically finish the verification. If it depends on an integration, a simulated response needs to cover the relevant condition.
The best model may depend on its environment
A study published in October 2026 evaluated 66 configurations and found changes in models' relative performance depending on the harness and task. That evidence is limited to the benchmarks studied; it establishes neither a universal winner nor an automatic prediction for your project.
The operational lesson I take from it is this: when performance worsens, investigate tools, error messages, available context, and stopping criteria alongside the chosen model.
Changing providers may help. It may also conceal an integration problem that will return later. Recording the complete configuration makes a comparison more useful than retaining only the AI's commercial name.
How I would evaluate this in a Laravel project
I would choose a small lab task: improve the processing of a fictional webhook while preserving behavior when events are repeated. I would use synthetic data and no access to real accounts. This scenario is an evaluation proposal, not a result already achieved at Oombe.
First, I would define what must remain true: the same event must not produce two equivalent changes; a failure must remain identifiable; another customer must not be affected. I would prepare independent checks before running the experiments.
I would compare three conditions while keeping the model, task, and budget equivalent:
- Basic guidance: the task description and access to the test project.
- A reusable procedure: the same task accompanied by a skill containing domain context and expected evidence.
- A procedure plus external controls: the same skill, with file, network, and action scope defined by the environment.
Every group would still run in a safe lab. The comparison does not require exposing a personal machine to manufacture a dramatic “before” scenario.
I would repeat the cases and examine outcomes, changes outside the intended scope, dependencies added, review time, and cost. I would also record blocked attempts: they help explain what the environment prevented, even when the final code looks similar.
One condition may cost more while reducing corrective work. Another may be fast but require extensive review. The decision depends on the task and the impact of mistakes. I would not begin with a promised savings percentage.
I would preserve the versions of both skills and tests. If everything changes between rounds, it becomes difficult to identify which modification explains the difference. That discipline creates learning the team can reproduce.
A good starting point fits inside a small task
For anyone putting these ideas into practice, I would start with a recurring task and a clear definition of success. I would document the procedure, constrain the environment, and review several complete executions. Then I would adjust whatever actually caused friction.
If the skill became too long, I would look for decisions it was trying to anticipate unnecessarily. If the agent requested broad access, I would examine which specific resource was missing. If it declared success too early, I would improve the evidence required to close the task.
Autonomy can grow alongside our knowledge of the system's behavior. In my work, that is more convincing than an exciting video: being able to explain what an automation does, where it may fail, and how someone can take control when needed.
Sources
- Agent Skills — specification.
- Anthropic — introducing Agent Skills.
- Anthropic — Building effective agents.
- Matt Pocock — Skills for Real Engineers.
- Addy Osmani — Agent Skills.
- NVIDIA OpenShell — architecture.
- DeepSeek Harness — official project and safety notice.
- Anthropic — Effective harnesses for long-running agents.
- Finding the Right Fit: Model-Harness Interactions across Agent Tasks.