Teaching agents to act

LLM agents are rapidly advancing in reasoning, tool use, and workflow orchestration. But as soon as an agent starts handling complex, multi-step workflows with long instructions, agent builders hit a hard engineering ceiling:

How do you give an agent access to hundreds or thousands of enterprise capabilities without overwhelming its context window?

The naive solution is to stuff hundreds of tool definitions, business rules, and operational guidelines directly into the system prompt. It works on a small scale but it breaks at enterprise scale.

Agent Skills offer a different architecture.

Skills package knowledge, instructions, operational know-how, and resources into modular, reusable capabilities that an agent can discover and load dynamically on demand.

The key shift is from always-loaded instructions to on-demand capability.

Agents need better context, not more context

Treating an agent's context window as an enterprise knowledge repository creates predictable architectural problems. The issue is not simply that large context windows are expensive. They can also make agents less reliable.

As more tool descriptions and complex instructions are added to the context, the model has to reason over an increasingly noisy information space. The relevant instruction may be present, but surrounded by irrelevant context, confusing the agentAlso, every additional token has an economic cost. If an enterprise agent carries hundreds of tool definitions and procedural instructions into every interaction, organizations pay to process information that is irrelevant to most requests.

A context window is optimized for task-specific reasoning, not for serving as the primary registry of every capability and procedure an enterprise possesses. An agent should not be forced to carry the organization's entire operating manual into every interaction.

Instead, it should be able to discover the relevant capability, load the knowledge and procedures required for that task, execute them, and then release that task-specific context.

Skills turn organizational know-how into a modular runtime capability that agents can discover, load, execute, evaluate, and govern.

Progressive disclosure: load context on demand

Skills operate using progressive disclosure: an agent only loads detailed procedural instructions after determining that a capability is relevant to the user's intent.

This creates a clean separation between discoverability and execution.

At discovery time, the agent only reads lightweight metadata describing what each Skill does and when it should be used. Once a Skill is selected, the runtime loads its detailed instructions, references, policies, and deterministic helper code.

A Skill therefore becomes a portable, versioned artifact rather than another block of text embedded in a system prompt.

Inside a Skill

A Skill packages the instructions, domain knowledge, and helper code required to perform a specific capability:

revenue-forecasting/
├── SKILL.md                  # Core instructions & workflow
├── references/               # Domain context loaded on demand
│   ├── forecasting-methodology.md
│   └── metric-definitions.md
└── scripts/                  # Deterministic helper code
    └── generate-forecast.py

The initial evaluation layer remains intentionally lightweight:

name: revenue-forecasting
description: >
  Generate and explain revenue forecasts using the
  enterprise-approved forecasting methodology.

The agent can scan metadata across hundreds of Skills without loading their full instructions. Once a Skill is selected, SKILL.md provides the instructions and points to the resources needed for the task:

# Revenue Forecasting
## When to use
Use for revenue forecasts, projections, or quarter/year-end estimates.

## Workflow
1. Validate the available revenue data and current sales pipeline data
2. Load the relevant metric definitions.
3. Apply the approved forecasting methodology.
4. Generate the forecast.
5. Explain assumptions and uncertainty.
## Resources
- `references/metric-definitions.md`
- `references/forecasting-methodology.md`
- `scripts/generate-forecast.py`

This is progressive disclosure in practice: discover the Skill through metadata, then load only the instructions and resources required for the task.

Skills guide and shape agent behavior

Skills work alongside capabilities such as tools, code execution, and MCP to enable reusable, controlled execution. Capabilities give the agent ways to act, while Skills provide the instructions and expertise for using them effectively.

Example: Revenue forecasting agent

A finance manager asks:

“Forecast Q4 revenue based on our latest sales data.”

The agent first scans Skill metadata and identifies several potentially relevant capabilities:

revenue-forecasting
financial-analysis
sales-pipeline-analysis
customer-churn-analysis

Based on the request, it selects revenue-forecasting and loads the SKILL.md and resources described above.

The Skill's instructions tell the agent to validate the data, load the approved metric definitions, apply the enterprise forecasting methodology, and explain assumptions and uncertainty.

Following those instructions, the agent uses MCP to access the relevant enterprise systems and retrieve the data required by the Skill, including historical revenue, current pipeline data, and the approved financial metrics:

It then uses the deterministic forecasting script specified by the Skill to generate the forecast and applies the Skill's instructions for explaining the assumptions and uncertainty.

The result might be:

Q4 forecast:     $49M
Confidence range: $46M–$52M
Key assumption:  62% pipeline conversion

The important point is that the agent isn't simply asked to “predict revenue.” The revenue-forecasting Skill tells it how the organization performs revenue forecasting, which data and definitions to use, which methodology to apply, and how to communicate uncertainty.

Discovering and managing Skills at enterprise scale

As organizations move from a handful of Skills to hundreds or thousands, managing and discovering reusable capabilities becomes increasingly important. A central Skill registry can provide an authoritative catalog where Skills are published, versioned, governed, and made available for reuse across agents.

A registry does not necessarily mean that agents dynamically search the entire catalog at runtime. An agent builder may still define which Skills an agent is allowed to use, while the registry provides the authoritative definitions and supports discovery and reuse across the organization.

For larger Skill sets, runtime retrieval can become an additional option. Instead of exposing the metadata or instructions for every available Skill in the agent's context, a system can retrieve a smaller set of candidate Skills based on the current task and then load the relevant instructions. Semantic or hybrid retrieval can be useful for this purpose, but it is a routing mechanism rather than an inherent requirement of a Skill registry.

Routing Skills to the right task

A single user request can map to multiple capabilities with different operational objectives.

Example: Consider the prompt “Why did revenue fall last quarter?” Depending on intent, this could involve financial analysis, compliance reporting, predictive forecasting, or customer churn analytics.

Matching purely on semantic similarity can be insufficient in complex enterprise environments. Scalable Skill routing can combine:

• Context & Task Constraints: Evaluate user intent against required inputs, available tools, permissions, and operational policies.

• Retrieve-and-Rerank: Narrow the Skill catalog through lightweight retrieval, followed by context-aware candidate selection.

• Ambiguity Handling: Surface cases where multiple Skills remain plausible rather than silently selecting an uncertain workflow.

This should be viewed as an evolution of Skill discovery rather than a requirement for every agent. For smaller, curated Skill sets, exposing lightweight metadata and allowing the agent or builder to select the appropriate Skill may be sufficient. As the number and overlap of Skills increase, retrieval and more sophisticated routing mechanisms can become increasingly useful.

Evaluating Skills for reliability

Once Skills become reusable organizational capabilities, the problem is not only how to discover and select them, but also whether they behave reliably when introduced into different agents and workflows. Routing quality is closely tied to Skill design quality. A poorly specified Skill may be triggered unintentionally, interfere with adjacent Skills, or fail to produce the expected outcome. To manage this, evaluation can cover five dimensions:

• Selection Accuracy: Is the Skill activated for relevant queries while remaining dormant for unrelated ones?

• Isolation: Does it work without relying on implicit state, unintended files, or unstated dependencies?

• Coexistence: Does introducing the Skill negatively affect existing Skills?

• Instruction Following: Does the agent follow the Skill's defined workflow, validation logic, and constraints?

• Outcome Quality: Does the Skill produce a correct, useful, and actionable result?

Evaluation should include positive, negative, and ambiguous cases, and become part of automated deployment and testing.

Teams can also measure the incremental value of a Skill by comparing agent performance on equivalent tasks with and without the Skill under controlled conditions. This measure can be referred to as Skill Lift.

These measurements can guide decisions to improve, consolidate, version, or retire Skills.

At enterprise scale, the registry provides the foundation for managing Skills as reusable organizational capabilities, while routing and evaluation help ensure they are used reliably.

Conclusion: Skills in agent architecture

Skills provide a way to equip capable models and tools with the instructions and context they need, making the right knowledge and guidance available when it is needed. As enterprises scale their agents, competitive advantage will increasingly depend not only on the models and tools they use, but on how effectively they encode, govern, evaluate, and reuse how work gets done. In this context, skills serve as an abstraction layer between what an agent can technically access and what an organization knows how to do, making the engineering of this layer increasingly important as agents move from demos to enterprise systems.

To see how this architecture comes to life in practice, explore how Skills work in Dataiku 15.