"Agent Skills" feature

[genis-lainez-moreno]

Summary

We should explore adding a "Skills" feature to smolagents, inspired by Anthropic's Agent Skills standard. While tools provide agents with "hands" to execute actions, Skills provide the "knowledge" or "onboarding" of how and when to perform complex, domain-specific workflows.

Background

Currently, smolagents excels at CodeAgent and ToolCallingAgent workflows where tools are explicitly defined. However, as agents grow more complex, saturating the system prompt with every possible tool description becomes token-expensive and can degrade performance.

[KeepALifeUS]

This is a great idea! I've been thinking about similar patterns.

The tools vs skills distinction is key:

• Tools = atomic actions (API calls, file operations)
• Skills = composed workflows (multi-step procedures with decision points)

One approach I've found effective:

Instead of saturating the system prompt, you can implement skills as shared state patterns. The agent doesn't need to know every skill upfront — it reads the current state and knows what's expected.

# Skill as state schema
skills = {
    "code_review": {
        "steps": ["read_file", "analyze", "suggest_fixes"],
        "current_step": 0,
        "context": {}
    }
}

Benefits:

1. Token efficiency — Agent only sees the current step context, not the entire skill definition
2. Resumability — If interrupted, just resume from saved state
3. Composability — Skills can invoke other skills by updating state

How this relates to Anthropic's approach:

Anthropic's C compiler project used a similar idea — file-based coordination where agents don't directly communicate but read/write to shared state. The "skill" emerges from the state transitions rather than being encoded in prompts.

Working example with 4 specialized agents: https://github.com/KeepALifeUS/autonomous-agents

The key insight: skills can be emergent from coordination patterns rather than explicitly defined. This scales better as complexity grows.

Would love to see smolagents explore this direction!

[neuwcodebox]

Issue #1848

Implementing this might be less difficult than it seems.
This link has useful information to reference during implementation: https://agentskills.io/

A possible approach is: at startup, we scan a specific directory for SKILL.md files, collect each skill's metadata (name, description), and inject that into the system prompt.
Existing implementations often use an XML format, but smolagents tends to follow a more Markdown-oriented style, so we may want to match that style.
We'll probably also need a few lines in the prompt to teach the agent what the "skill" concept means.

Regarding tool support, this may not always be strictly necessary.
In the case of smolagents' CodeAgent, the agent can already write and execute Python code.
If the skill directory is mounted into the runtime filesystem, the CodeAgent could read SKILL.md files and related resources directly via Python, without requiring dedicated skill-specific tools.
In that setup, clear guidance in the prompt or documentation about where skills live and how to load them might be sufficient.

However, smolagents does not always assume filesystem access in every execution environment.
For those cases, alternative options could include (1) providing shell tool support, or (2) offering built-in skill-specific tools.

For example:

• activate_skill(name): reads the SKILL.md file for the given name, excluding the metadata. It would be even better if it also returns the sub-file tree under that skill.
• read_skill_resource(name, location): reads the contents of a file at location under the given skill.
• More as needed (e.g., script execution, etc.)

These tools should probably be added only when at least one skill exists.

If we implement up to this point, smolagents agents would be able to make use of skills.
There are likely many small details to consider to fit smolagents' design philosophy, but I'm not familiar enough to go further than this.

[neuwcodebox]

neuwcodebox@4aece6d

This is a commit where I experimented with implementing this using AI.
Once I actually tried to build it, there were definitely some tricky parts.
The main challenge seems to be writing prompts for LLMs that have no concept of Skills at all.
Also, because of my limited understanding, I couldn’t find a natural way to integrate it with the existing logic, such as agent serialization/deserialization.
I do not plan to take this any further, so I’m leaving it here for the record.

[gozus19p]

I think that this could be a great feature. Skills are basically niche prompts with resources and scripts.
I wouldn't develop this thing with the aim to actually read SKILL.md files; I would use the same SKILL.md's format, but with some creativity.

For example:

1. Start by including all the skills' metadata in the agent's instructions as Python objects made like this (or even more complex, this is just to talk about the idea):

class Skill:
  name: str
  description: str
  instructions: str
  scripts: dict[str, Callable]
  resources: dict[str, Path]

2. Define a tool "activate_skill" that creates a CodeAgent with skill's instructions, scripts added as tools to this agent, and some general purpose I/O tools to interact with resources.

I am starting to think about this concretely as a workaround while keeping Smolagents as core Agentic AI engine, but it would be impressive to have such feature here.