Skills and agents are not competing choices — they operate at different abstraction levels. Skills are composable, discoverable, versionable procedures that tell an agent how to perform a class of work. Agents are goal-directed runtimes that consume skills to navigate uncertainty across multiple steps. By mid-2026, skill engineering has emerged as a recognized third layer of AI engineering (above agent and infrastructure engineering), as named by The Turing Post. The four formal properties of a skill: composable (combines with other skills at runtime), discoverable (agents find and select dynamically), versionable (lifecycle-managed independently from the agent), and reusable (one definition works across many agents and contexts). The critical insight from the research: the policy problem — when to activate a skill inside the agent's decision loop — is architecturally separate from the skill definition. MCP is becoming the distribution layer: skills are shifting from hardcoded prompt files to protocol-native artifacts discoverable over HTTP. The unresolved security concern: a skill loaded from an external source runs inside the agent's context window and carries the same supply-chain attack risk as an npm package.
The common mistake is treating "skill" and "agent" as competing product names. They are different abstraction levels. A skill packages procedural knowledge: instructions, examples, scripts, templates, reference files, and constraints that a model can load when needed. An agent is a runtime actor: it receives a goal, observes state, plans steps, calls tools, handles feedback, and may hand work to other agents.
Recent research is converging on this split. Surveys of agent skills describe skills as reusable procedural artifacts that reduce repeated low-level reasoning. Surveys of agentic AI architectures describe agents as systems with perception, planning, memory, action, tool use, and collaboration. Official platform docs show the same pattern in practice: Anthropic Agent Skills package capability bundles, while the OpenAI Agents SDK manages tools, guardrails, handoffs, sessions, and traces.
What Research Says
Early agent papers explain why agents are powerful and expensive. ReAct showed that interleaving reasoning and actions helps models plan, update state, and use external sources. Toolformer showed that models can learn when and how to call external APIs. Reflexion added verbal feedback loops for improving future attempts. Voyager made the skill idea concrete: an embodied agent builds a growing library of executable skills and reuses them in new worlds.
Newer papers focus on the operational layer. Agentic Tool Use in Large Language Models organizes tool use into prompting, supervised learning, and reward-driven policy learning, and highlights failure modes in tool selection and execution. Agent Skills for Large Language Models frames skills as an emerging infrastructure layer with acquisition, architecture, deployment, and security concerns. SkillGen treats skills as interventions whose net effect should be verified, which is a useful engineering principle: a skill is only valuable if it improves task quality, cost, or repeatability.
Skill Engineering: The Recognized Third Layer
By mid-2026, the practitioner community has settled on a three-layer model of AI engineering. The Turing Post names them: infrastructure engineering (compute, serving, model tooling), agent engineering (orchestration, memory, tool use), and — newest — skill engineering: giving agents reusable procedures they can discover, apply, version, and reuse across tasks. Skills are a layer above agents, not an alternative. Agents consume skills; skills do not replace agents.
Research formalizes four properties that distinguish a skill from a plain instruction file (arXiv 2602.12430v4). A skill is composable (combines with other skills at runtime), discoverable (agents find and select dynamically — not hardcoded at build time), versionable (lifecycle-managed independently so you update the skill without redeploying the agent), and reusable (one definition works across multiple agents, personas, and task contexts). A critical architectural insight: the policy problem — when to activate a skill inside the agent's decision loop — is architecturally separate from the skill definition — what the skill instructs the agent to do. A correct skill can still fire at the wrong time if the harness's selection logic is flawed.
Decision Rule
Comparison
| Dimension | Skill | Agent | Business implication |
|---|---|---|---|
| Complexity | Lower. Mostly instructions, examples, assets, scripts, and usage rules. | Higher. Needs runtime state, planning, tool routing, error handling, observability, and permissions. | Start with skills unless the workflow truly needs autonomy. |
| Flexibility | Flexible inside a known procedure; weaker when the task path changes dynamically. | Flexible across changing situations because it can choose actions from observations. | Use agents for variable workflows, not for every repeatable task. |
| Maintenance | Version like documentation plus scripts. Review when policy, examples, or tools change. | Maintain as software: tests, traces, evals, permissions, cost budgets, incident response, and rollback. | Agents have a larger operational burden and need explicit owners. |
| Cost control | Usually cheaper because it reduces repeated planning and narrows context. | Can be expensive because loops create repeated model calls, retrieval, tool calls, and validation steps. | Package stable work as skills; reserve agent loops for uncertainty. |
| Abstraction | Capability abstraction: how to do a type of work. | Responsibility abstraction: who is driving a workflow toward an outcome. | Skills standardize expertise; agents own execution state. |
Cost Control
Skills control cost by making the model spend fewer tokens rediscovering a procedure. They can load only the relevant checklist, examples, schema, or script. Agents control business value by navigating uncertainty, but that uncertainty creates variable cost. A single agentic workflow can include planning calls, retrieval, tool calls, retries, validation, summaries, and human review packets.
Use Cases
| Scenario | Prefer skill | Prefer agent |
|---|---|---|
| Marketing and content | Brand voice, product claim checklist, image prompt style, SEO checklist, legal-review format. | Campaign coordinator that gathers inputs, schedules work, checks approvals, and publishes through CMS tools. |
| Engineering | Repo-specific testing workflow, migration guide, release-note format, code-review checklist. | Incident agent that watches alerts, inspects logs, opens PRs, requests approvals, and tracks rollback. |
| Customer support | Tone guide, escalation taxonomy, refund-policy summary, CRM note format. | Case-resolution agent that reads account state, calls tools, proposes resolution, and escalates exceptions. |
| Finance and operations | Monthly-close checklist, invoice validation rules, variance-analysis template. | Workflow agent that reconciles records across systems, asks for missing evidence, and routes approvals. |
Maintenance Model
When To Combine Them
The best architecture is usually not "skills or agents." It is "agents with skills." A production agent should not improvise every subtask from scratch. It should load approved skills for stable procedures, call typed tools for external action, and escalate when the situation exceeds its policy or confidence boundary. This mirrors the research pattern in Voyager's skill library and the platform pattern in modern agent SDKs: reusable procedural knowledge below, goal-directed orchestration above.
Practical Rule Of Thumb
- Use a prompt when the instruction is temporary.
- Use a tool when the model needs a typed external capability.
- Use a skill when the organization has a repeatable way to do the work.
- Use an agent when the system must own a changing workflow across time, tools, state, and exceptions.
- Use multiple agents only when role separation, permissions, or parallel workflows justify the coordination cost.
References
- A Comprehensive Survey on Agent Skills: Taxonomy, Techniques, and Applications
- Agent Skills for Large Language Models: Architecture, Acquisition, Security, and the Path Forward
- SkillGen: Verified Inference-Time Agent Skill Synthesis
- Agentic Tool Use in Large Language Models
- Agentic Artificial Intelligence: Architectures, Taxonomies, and Evaluation of Large Language Model Agents
- ReAct: Synergizing Reasoning and Acting in Language Models
- Toolformer: Language Models Can Teach Themselves to Use Tools
- Reflexion: Language Agents with Verbal Reinforcement Learning
- Voyager: An Open-Ended Embodied Agent with Large Language Models
- Anthropic Engineering: Equipping agents for the real world with Agent Skills
- OpenAI Agents SDK documentation
- OpenAI: A Practical Guide to Building Agents