Harnesses, skills, tools, and MCP
How to combine harnesses, skills, tools, and MCP integrations in development with AI agents without creating unnecessary complexity.
Updated: November 14, 2026
The evolution of AI agents has introduced different resources for structuring execution, reusing procedures, and integrating tools. Harnesses, skills, tools, and MCP integrations serve distinct functions but are frequently used redundantly or with more complexity than necessary.
Not every need requires a new skill, MCP server, or another agent. Many capabilities are already available in development environments, while others can be addressed with instructions, scripts, or existing tools.
The goal is to understand each component's responsibility and choose an appropriate approach, avoiding unnecessary dependencies and keeping the development environment simple, secure, and efficient.
1. Understanding each component's responsibilities
Before adding resources to the environment, it is important to distinguish their responsibilities.
| Component | Responsibility |
|---|---|
| AI model | Interprets instructions, analyzes information, makes decisions, and produces responses or proposed actions. |
| Agent | Uses the model in a flow capable of interacting with tools, observing results, and executing steps toward an objective. |
| Harness | Provides the agent's execution structure, including tools, context, permissions, session management, and control mechanisms. |
| Skill | Provides reusable instructions and resources for executing certain types of work. |
| Tool | Allows concrete operations such as reading files, running commands, querying services, or modifying code. |
| MCP | Standardizes connections between AI applications and servers providing tools, resources, and prompts. |
These components can work together but are not direct substitutes.
A skill can guide how to execute a procedure while a tool performs the necessary operations.
The harness provides and controls these capabilities, and the model decides how to use them within established instructions and permissions.
Understanding this separation helps avoid solutions that introduce layers without real advantages.
2. Harnesses: the structure supporting execution
The harness is the software infrastructure allowing the agent to work with tools and interact with the environment.
Depending on implementation, it may be responsible for:
- Providing tools and controlling their calls.
- Managing sessions and execution history.
- Loading instructions and context.
- Controlling permissions and approvals.
- Organizing execution cycles.
- Recording results and errors.
- Applying limits and stopping conditions.
- Integrating validation mechanisms.
Environments such as IDE coding agents and command-line development tools already offer different resources of this kind.
This means developing custom orchestration infrastructure is not always necessary.
When should an existing harness be used?
For most AI-assisted coding activities, it makes sense to begin with the resources in the environment the team already uses.
If it offers file reading and editing, command execution, necessary tool access, and suitable control mechanisms, creating another layer may increase complexity without improving results.
A custom implementation starts making more sense when available tools do not meet requirements such as specific execution flows, internal integrations, security policies, or coordination among multiple agents.
The choice should begin with necessary capabilities, not an intention to build an agent environment from scratch.
3. Skills: when they actually make sense
Skills provide reusable instructions, references, and procedures for certain kinds of work.
However, not every task justifies creating a skill.
Modern models and agents already know various languages, frameworks, and libraries. Furthermore, certain environments include capabilities and skills for recurring tasks.
Creating a skill simply to teach an agent React, Tailwind, or TypeScript generally duplicates knowledge.
A skill's value appears mainly when a specific procedure needs consistent execution.
For example:
- Creating components following a design system's particular rules.
- Implementing integrations according to a company's internal requirements.
- Executing specific deployment procedures.
- Preparing migrations following project-specific policies.
- Producing test evidence in a team-required format.
- Performing specific security or compliance checks.
A skill can combine instructions, references, examples, and scripts needed for that procedure.
Skill or documentation?
Not every convention needs to become a skill.
If the objective is stating that the project uses a particular library, architecture, or pattern, context documentation may be sufficient.
If a reusable flow exists with specific stages, checks, and its own resources, a skill may be more appropriate.
Documentation establishes project context and rules. Skills organize reusable procedures for executing specific work.
This distinction also helps avoid repositories accumulating dozens of skills that merely repeat documentation.
External reference: Agent Skills — specification.
Related reading: Context architecture, engineering, and documentation.
4. Using existing capabilities and skills
Before creating any resource, check what the development environment already offers.
Many AI coding tools provide mechanisms to navigate code, run tests, interact with browsers, search documentation, and work with files.
Some also include their own skills or allow installation of reusable resources.
Creating alternative versions of these capabilities can generate additional maintenance, behavioral differences, and uncertainty over which resource to use.
A practical evaluation should consider:
- Does the agent already possess the necessary knowledge?
- Does the environment already offer the operational capability?
- Is a suitable skill or integration available?
- Does the project have any particulars requiring additional instructions?
- Does creating a custom resource offer a concrete advantage?
Consider developing an interface with Tailwind.
The agent normally already knows utility classes and framework concepts. There is no need to create a generic skill explaining flex, grid, or spacing.
However, if the project uses custom tokens, standardized components, and specific constraints, that information should be available in project context.
An additional skill is justified only if a particular procedure actually benefits from this structure.
The same principle applies to backend, databases, tests, and infrastructure.
5. Tools: operational capabilities
Tools allow agents to perform operations in the environment.
This includes running commands, modifying files, querying APIs, accessing databases, searching, and interacting with external applications.
The existence of a tool does not imply a need for a skill or MCP.
For example, if the agent already has terminal access, it can run project-defined test scripts.
There is no need to create a skill just to run npm test or develop an MCP server to expose that command.
Likewise, an existing script can perform code checks, generate files, or validate contracts without another integration layer.
Prefer deterministic operations when possible
An important part of efficiency is using traditional tools for operations that do not require model decisions.
Linters, compilers, type checkers, and automated tests remain appropriate mechanisms for validating objective code aspects.
The agent can run these tools, interpret results, and make decisions when necessary.
This avoids using AI models to reproduce checks with reliable implementations already available.
AI should coordinate and interpret when necessary, not indiscriminately replace tools that already solve the problem.
6. MCP: when to use it and when to avoid it
The Model Context Protocol (MCP) offers a communication standard connecting AI applications to servers providing tools, resources, and prompts.
It can facilitate integration with external systems and allow different compatible clients to reuse the same capabilities.
Possible applications include:
- Querying and updating tickets in management systems.
- Accessing design tools.
- Interacting with internal services.
- Querying database information.
- Integrating observability platforms.
- Exposing corporate API operations.
However, MCP is not mandatory for every integration.
If the agent can already execute an operation through an existing tool, script, or direct API call, adding an MCP server may just introduce another dependency.
When does MCP add value?
MCP is especially useful when an integration needs to be provided in a standardized manner to different agents or environments.
It can also help encapsulate specific operations, control exposed capabilities, and facilitate maintenance of shared integrations.
Conversely, developing a custom MCP server to run simple commands or access already available functionality may not offer proportional benefits.
Remember that MCP does not automatically guarantee security. Authentication, authorization, data handling, and operational limits remain implementation and environment responsibilities.
MCP is an integration protocol, not a requirement for an agent to use tools.
External reference: Model Context Protocol — official documentation.
7. Choosing the appropriate solution
Before implementing a new resource, identify the nature of the need.
Some problems require knowledge. Others need instructions, operational capabilities, integrations, or execution control.
| Need | Initial approach |
|---|---|
| Communicate project architecture and standards | Context documentation |
| Establish general agent instructions | AGENTS.md or equivalent mechanism |
| Reuse a specific procedure | Skill, when justified |
| Run existing tests or commands | Native tools and scripts |
| Integrate an external service | Existing integration, direct API, or MCP |
| Share tools among AI clients | MCP may be advantageous |
| Control permissions, cycles, and execution | Harness and orchestration mechanisms |
| Preserve progress between sessions | Persistence resources and state files |
These alternatives are not mutually exclusive.
A skill can use tools, while an MCP server can expose operations consumed by the agent.
What matters is not creating components simply because the technology is available.
A good rule is starting with the simplest solution meeting requirements and adding layers only when an identified need exists.
External reference: AGENTS.md — agent instructions.
8. Combining components in an execution
Consider a request to implement a feature involving frontend, backend, and external API integration.
The environment can combine different resources without creating a complex agent architecture.
Project context
The agent consults general instructions, API contracts, and standards corresponding to involved modules.
Harness
Provides file, terminal, tool, and control mechanism access needed to execute the task.
Skills
If the project has specific procedures for creating endpoints, validating integrations, or preparing tests, the agent can use the corresponding skills.
Tools
Used to modify code, run commands, consult files, and verify results.
MCP
Can be used if information or an operation depends on an external service whose integration is available through this protocol.
Validation
Automated tests and existing checks confirm results. The agent interprets failures and makes corrections within established limits.
In this scenario, each component has a responsibility.
There is no need to turn every stage into a separate agent, develop a skill for every operation, or introduce MCP servers where existing tools suffice.
The structure can evolve as work complexity justifies new mechanisms.
9. Security, permissions, and operational limits
Expanding agent capabilities also increases the importance of controlling which operations they can execute.
Tools accessing files, databases, external services, or production environments need to respect defined limits.
Some precautions include:
- Apply least privilege.
- Separate read and write operations when appropriate.
- Restrict access to credentials and sensitive information.
- Require approval for critical operations.
- Differentiate permissions across development, staging, and production.
- Record relevant operations for auditing.
- Avoid tools with excessively broad capabilities.
A skill should not be treated as a security mechanism.
It can guide expected behavior but does not replace technical authorization controls.
Likewise, an MCP server should not receive unrestricted permissions simply because it is available to the agent.
Permissions need enforcement by the environment and services used.
Critical operations
Production deployments, destructive database changes, and infrastructure modifications deserve additional controls.
Even when the agent has sufficient knowledge to execute these operations, that does not mean it should be authorized to perform them without approval.
Knowledge, capability, and permission are different responsibilities and should be treated separately.
Related reading: Standardizing projects for development with AI agents.
10. Execution validation and control
Execution quality should not depend exclusively on the agent's own assessment.
Whenever possible, the harness and available tools should support objective checks.
This may include:
- Running automated tests.
- Type checking and compilation.
- Static code analysis.
- Contract validation.
- Integration tests.
- Browser interface checks.
- Collecting execution evidence.
Control should also account for situations where the agent cannot complete a task.
Repetitive trial-and-error cycles can consume resources without progress.
Depending on the environment, execution limits, stopping conditions, and mechanisms to request human intervention can be established.
These responsibilities do not need implementation inside skills.
When the harness already offers suitable control and validation mechanisms, prefer them over reproducing the same logic across different procedures.
Separating execution from approval
An agent can implement a feature and run tests, but delivery approval may require additional checks.
In critical projects, human review or an independent validation stage may remain necessary.
The process should consider change risk and project-established quality criteria.
Related reading: Failure recovery in AI agents.
11. Avoiding complexity and redundancy
The ease of creating agents, skills, and integrations can lead to environments with more components than necessary.
Generic and redundant skills
Creating instructions for knowledge the agent already possesses or capabilities already available in the environment.
Duplicate tools
Providing different tools performing the same operation without clear selection criteria.
Unnecessary MCP servers
Creating servers for operations that could be performed directly by scripts, commands, or existing integrations.
Conflicting instructions
Maintaining different rules in skills, documents, and configurations so the agent receives incompatible guidance.
Excessive orchestration
Distributing simple tasks among several agents when one execution would suffice.
Fragmented maintenance
Repeating the same rules in several components, requiring multiple updates whenever the project changes.
These problems do not affect organization alone.
They may increase context consumption, complicate failure diagnosis, expand the security surface, and raise maintenance costs.
Needs-driven evolution
A more sustainable strategy is starting with available capabilities and adding components as concrete requirements emerge.
Before creating a skill, check whether a specific procedure justifies its maintenance.
Before developing an MCP server, assess whether the integration actually needs this standardization.
Before creating another agent or custom harness, identify which limitations of the current environment need resolving.
Whenever a new capability is added, update corresponding project context references so agents know when and how to use it.
Related reading: AI programming: strategies to reduce token consumption and increase efficiency.
Conclusion
Harnesses, skills, tools, and MCP integrations have distinct responsibilities and can complement each other in AI development.
The harness structures execution. Tools expose operations. Skills organize reusable procedures. MCP standardizes integrations. The model and agent use these resources to execute work.
However, the existence of these technologies does not mean all must be present in every project.
Much programming work can already be performed with agents' native capabilities, technical documentation, and traditional tools.
Additional skills and integrations should meet specific needs, especially where project-specific procedures or requirements are not covered by the environment.
Efficiency comes not from creating more agents, skills, or MCP servers, but from using existing capabilities and adding only components that actually improve project execution, security, and maintenance.
Share this article
Sources & further reading
This note is a practical introduction, not a substitute for the original documentation. Check source dates and implementation details before making technical decisions.