When should skills be used during deepagent operation?

[Smile0524]

self.agent = create_deep_agent(
model=model, # Claude Sonnet 4.5 with temperature=0
memory=["./AGENTS.md"], # Agent identity and general instructions
skills=["./skills/"], # Specialized workflows (query-writing, schema-exploration)
tools=try_method.get('tools'), # tools
subagents=[], # No subagents needed
backend=FilesystemBackend(root_dir=base_dir) # Persistent file storage
)
In my task, I defined four tools: A, B, C, and D, and created a skills.md file where I wrote the order in which these tools should be called for the task. However, when the program actually ran, I observed the trace and found that the information in the skills file was not used. Instead, the write_todos function directly wrote the calls for the four tools A, B, C, and D according to the tool descriptions.

[Berk Demirci (demirciberk)]

skills are not a hard orchestration mechanism for forcing a specific tool-call sequence.

Deep Agents use skills through progressive disclosure: at startup the agent sees the skill metadata/description, and it only reads the full SKILL.md when it decides that the skill is relevant to the current task. So if the model can already infer a reasonable plan from the tool descriptions, it may proceed without loading that skill.

In your case, if the order A → B → C → D must always be followed, I would not rely on a skill alone to enforce it. A skill is better suited for reusable domain knowledge, detailed workflows, reference material, or instructions that are only needed for certain tasks.

A few things I would try:

Make the skill description very specific about when it should be activated, because the agent initially decides whether to use the skill based on that metadata.
If the sequence is always required, put that requirement in always-loaded instructions such as the system prompt / memory rather than only in a skill.
If the sequence must be deterministic, enforce it structurally in the workflow/tool design instead of depending on the LLM to choose the order.

So I think the behavior you're seeing is expected: skills provide on-demand guidance, but they do not guarantee that the agent will load them or use them to override its own tool planning.

Docs: https://docs.langchain.com/oss/python/deepagents/skills

[Nima Simyari (NimaSimyari)]

One thing I’d add is that write_todos and skill activation are really two separate decisions.

The agent can build a reasonable A → B → C → D plan from the tool descriptions before it ever decides to open the skill. Since only the skill name and description are visible initially, putting the required order only inside SKILL.md doesn’t guarantee that it will be read.

If that sequence is mandatory, I’d move the invariant into AGENTS.md or the system-level instructions, for example:

For this workflow, always execute A → B → C → D. Do not skip or reorder steps.

If the order is truly strict, I’d go one step further and enforce it in code rather than prompt it — for example by exposing a single workflow tool that internally runs A/B/C/D, or by modeling the sequence as explicit graph states.

I’d still keep the skill for the detailed reasoning around each step, but not use it as the control-flow mechanism.

[grandocean (173787247)]

Skills are not a hard workflow engine. They are extra markdown the model may read. write_todos + tool schemas will almost always win if they already describe A→B→C→D.

Why your skills.md was ignored

• skills=["./skills/"] is loaded as optional context, not as a constraint compiler. Temperature 0 does not force skill-following.
• If tools A–D are all bound and their docstrings already imply the order, the agent plans from tools, never opens the skill file.
• A single skills.md with “call A then B…” is easy to skip; Claude Code-style skills work better as SKILL.md with frontmatter + a trigger (when to use this skill) and a short procedure.

Make the order actually run

1. Don’t rely on skills for sequencing. Put the order in the graph: a fixed subgraph / interrupt / sequential nodes, or one tool run_pipeline() that calls A–D internally.
2. If you want skills: name the folder like skills/query-writing/SKILL.md, start with YAML name / description that matches the user task, and in memory/AGENTS.md add: “For this task you MUST open skills/query-writing/SKILL.md before tools.”
3. Trace: if there is no read_file of the skill path, the skill never entered context. That’s expected with create_deep_agent + rich tools.

When to use skills: specialized, occasional procedures (schema exploration, rare APIs) that shouldn’t bloat the system prompt. When not to: a mandatory 4-step tool pipeline — that’s code, not a skill.