Announcing Zep Agent Skills

Today we're announcing Zep Agent Skills. Long-horizon agents in production often encounter business problems their prompts and skills don't anticipate. What they learn solving these problems is lost. When the agent meets a similar problem, the slow and expensive work of solving it begins again.

Zep Agent Skills turns your agent's successes and failures into repeatable procedures that your agent can reuse at runtime. Later runs refine each Skill, so the agent's capabilities improve over time.

Skills created by Zep make agents more reliable and efficient. On the EnterpriseOps-Gym business process benchmark, Claude Haiku 5.5 with Skills improved by 12 points, and DeepSeek V4.1 Flash with Skills outperformed Claude Opus 5.5 at maximum effort without them.

Procedures delivered as SKILL.md files

A Skill is a versioned procedure for one kind of task, rendered as a SKILL.md file in the open Agent Skills format. Most agent frameworks can load SKILL.md files. At task time, the agent searches for applicable Skills and reads the current version.

Zep records each run, or imports runs from your observability platform, and groups them into task families automatically so similar tasks don't splinter into many Skills. Only runs whose success was confirmed by something other than the agent, such as a tool or an evaluation in your observability platform, can support a Skill. A compiler turns those runs into a new Skill or a change to an existing one. Before admission, code checks that every claim cites a recorded event from those runs. Instance-specific data is replaced with placeholders, and instructions that came from tool output are rejected.

Unlike research systems such as Trace2Skill and SkillRevise, Agent Skills runs as a production service. Each step of a Skill links back to the run events it came from, and each change is an immutable version you can compare or restore. Deleting a source run removes every Skill that cites it, and Skills stay within the agent's security domain. Verified uses raise a Skill's retrieval rank and verified failures lower it.

The research behind it

We've published the research behind Agent Skills in Learning by Doing: Autonomously Compiling and Curating Agent Skills from Verified Traces, a preprint on arXiv. The paper describes in detail how Agent Skills works and how we evaluated it.

For the paper, we selected three benchmarks that contain tasks similar to what many Zep customers encounter: τ³-bench banking, AppWorld, and EnterpriseOps-Gym. We used a teacher/executor setup, with Skills compiled from Claude Opus 5.5's traces. We then gave the Skills to three smaller executor models: GPT-6 Luna, Claude Haiku 5.5, and DeepSeek V4.1 Flash.

The executor models performed at or near Opus 5.5, often with fewer tokens and lower latency.

• On EnterpriseOps-Gym, DeepSeek V4.1 Flash with Skills passed 58.3%, up 10 points over the baseline. This result beat Opus 5.5, the teacher, at maximum effort.
• Pass rates rose by up to 18.8 points for GPT-6 Luna, Claude Haiku 5.5, and DeepSeek V4.1 Flash, across a variety of reasoning-effort combinations.
• On τ³-bench banking, where episodes run long, Skills cut tokens per passed episode by up to 45%.

We also compared Skills with continuous fine-tuning, which trains a model on an agent's successive runs. An earlier paper reported that continuously fine-tuning a small Qwen3-8B model on the ALFWorld benchmark produced a 13.7-point improvement. With Zep Agent Skills, Qwen3-8B improved by 32.6 points with no training.

If you're interested in running the benchmarks yourself, we've published the benchmark harnesses on GitHub.

How Agent Skills fits your stack

Your application runs the agent and its evaluations. The agent reads a Skill and decides how to act, and the application reports each outcome to Zep.

Any trace source. If your agent already sends traces to Braintrust or LangSmith, Zep imports them as Traces. An evaluation score you already compute can mark each imported outcome as externally verified. The traces you already collect can produce Skills with no new instrumentation. Agents without an observability platform send Traces with the Zep SDK.

Any framework. Agents read Skills through the Zep Context MCP server, which gives an agent tools to find Skills and to report each use and its outcome, or through the Python and TypeScript SDKs. Reference implementations for LangGraph, Google ADK, and the Claude Agent SDK capture Traces using each framework's own hooks.

Any model. Skills use a standard format, so they work with any model. A useful pattern is to use a frontier model as the teacher on new tasks, so that smaller, cheaper models can complete the same or similar tasks using its Skills. A Skill learned by one agent can also be shared with another in the same security domain.

Where Skills help and their limits

Today, Agent Skills compiles procedures from verified successes, so a task no agent has solved gets no Skill of its own. We're working on learning from unsuccessful runs too, so agents keep improving on problems they haven't yet solved.

On tasks a model already handles well, the gain is small. Agent Skills is designed for challenging, long-horizon business tasks that agents struggle with. A good first task family is a multi-step procedure that a smaller model gets wrong on its own and that your agent runs often.

Get started

Agent Skills is available to every Zep account, free for the next 60 days.

• Sign up at app.getzep.com and follow the quickstart.
• Run the banking example. The example runs Claude Haiku 5.5 on a synthetic banking correction task, runs Claude Opus 5.5 on a separate case, uploads the passing Trace, waits for Zep to compile and admit a Skill, and then reruns Haiku with it.
• Try your framework. The framework examples run the same loop on LangGraph, Google ADK, and the Claude Agent SDK.
• Read the docs at help.getzep.com/agent-skills, including trace import and admission settings.
• Read the paper on arXiv.

FAQ

Written byDaniel ChalefFounder and CEO, Zep

@danielchalefLinkedInAll posts