# EvoSkill writes new agent skills out of the agent's own failures

> EvoSkill is a Python framework that runs a coding agent against a benchmark, reads the trajectories where it failed, and synthesises new reusable skills and prompt variants that are then evaluated on held-out data. It ships with adapters for six agent harnesses and with Harbor for containerised task benchmarks.

**sentient-agi/EvoSkill** — EvoSkill — An open-source framework that automatically discovers and synthesizes reusable agent skills from failed trajectories to improve coding agent performance.

- Repository: https://github.com/sentient-agi/EvoSkill
- Stars: 1,291 · Forks: 133
- Language: Python
- License: Apache-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/sentient-agi-evoskill

## The loop turns failures into skills

EvoSkill is described as an open-source framework that automatically discovers and synthesises reusable agent skills from failed trajectories, and the README frames it as turning general agents into specialists with a benchmark and EvoSkill. The mechanism extends the feedback-driven idea of GEPA from single-file optimisation to complete agent evolution. Instead of only revising one prompt in place, EvoSkill proposes multiple skill and prompt mutations jointly, evaluates the new variants on held-out data, and has each iteration produce an entirely new agent program. The output is not a tuned prompt but a set of skills, and the skills are packaged as reusable folders with instructions, metadata and helper scripts, which is what makes them transferable between agents.

## Six harnesses, each with its own integration detail

The supported agent table is the part to read before you install, because each row carries a caveat that determines whether the adapter will work for you. Claude Code is supported with no notes. OpenCode requires CLI v1.4.0 or later, for structured output support. OpenHands has no native structured output and uses a fallback JSON extraction. Goose requires CLI v1.25.0 or later, with skill discovery via the summon extension. Codex CLI discovers skills through a `.agents/skills/` symlink. Harbor is described as containerised task benchmarks with built-in verifiers. The pattern is that the adapters need different amounts of cooperation from the agent, and the ones that need structured output get cleaner skill files than the ones that fall back to parsing text.

## Install with one script, or set it up by hand

The recommended install is a single command that clones and installs everything:

```bash
# Clone + install everything (Python deps, uv, optional agent CLIs)
curl -fsSL https://raw.githubusercontent.com/sentient-agi/EvoSkill/main/install.sh | bash

# Or, if you already cloned the repo:
./install.sh

# Install Python deps + all agent harness CLIs (macOS/Homebrew)
./install.sh --all-agents

# Install Python deps + specific agent CLIs
./install.sh --agents claude,opencode
```

The installer handles Python 3.12 and newer, uv and the uv sync step automatically, and Harbor comes with the Python package. The agent CLIs are optional, since you install only the harness you plan to use. The manual path is `uv sync` or `pip install -e .`, and then the harness CLIs themselves, which on macOS are Homebrew casks for claude-code and codex and plain formulae for opencode and the goose CLI.

## The dependencies are the agent SDKs

The package manifest is a good map of what the framework actually drives. The runtime dependencies include the SDKs for the harnesses it supports, with opencode-ai, openai-codex-sdk, claude-agent-sdk, openhands-sdk and openhands-tools, alongside the usual Python plumbing: click for the CLI, httpx for HTTP, pydantic and pydantic-settings for configuration, pandas for the trajectory data, pyyaml and tomli-w for config files, questionary and rich for interactive prompts, and tqdm for progress. Two entries are worth noting. `harbor` at version 0.6.1 and above is the benchmark harness, and `daytona` is the remote execution environment, which is what lets the evaluation run elsewhere. The heavier dependencies, dspy, datasets, torch and the llm-sandbox with Docker, live in the optional `eval` extra, and the notebook extras carry ipykernel, plotly and seaborn. The entry point is a single console script, `evoskill`, pointing at `src.cli.main:cli`.

## Three transferability claims, two open directions

The feature table separates what the project claims to do from what it is still working on. Evolution with a benchmark is done, and skills can be improved against your own or academic benchmarks. Cross-agent transferability is done, because the skills are packaged as reusable folders. Cross-model transferability is done, demonstrated in a paper where skills evolved with a fixed LLM transfer their performance increase to other LLMs. Cross-task transferability is done, with a SealQA skill improving BrowseComp performance as an example. The two rows marked as work in progress are evolution without a benchmark, where benchmarks are generated on the fly, and continuous evolution, which would improve skills from regular usage. That second one is the one a user is most likely to want, and the table is honest that it is not there.

## The container image covers all harnesses at once

The Dockerfile is aimed at running the whole thing in a container, and it installs the external binaries each harness needs rather than assuming them. The base is python 3.12 slim with git, curl, ca-certificates, gnupg and libgomp1, plus Node 20 from the NodeSource repository, because three of the harnesses are npm packages: claude, which the claude-agent-sdk spawns, opencode, whose harness spawns `opencode serve`, and codex, which the openai-codex-sdk spawns. Goose is different, since it is installed from a tarball of the GitHub release rather than from npm. The image can be built locally for a bring-your-own-computer run, and the comments explain the cross-compilation path for when you are on Apple Silicon and need an amd64 image, with the image name then set in the configuration file.

## Where the project sits

EvoSkill comes from Sentient Labs, with a paper, a blog post and a technical report PDF in the repository root, alongside a `notebooks/` directory, a `docs/` directory, an `examples/` directory with an officeqa example, a `scripts/` directory, and a `.claude/` directory. The Python project is built with hatchling, the wheel target packages the `src` directory, and the pytest configuration collects from a `tests/` directory. Coverage is configured with a `fail_under` of 80 and a list of files omitted from the measurement, including the CLI, the loop runner, the registry manager, the evaluation modules and the harness executors, which is a reasonable set of exclusions for a project whose core value is the harness glue. The last push to the main branch was on 2026-08-24, the most recent release was v1.3.0 in June 2026 adding a Fireworks AI provider, and the licence is Apache 2.0.

## Conclusion

Adopt EvoSkill if you are running coding agents against a repeatable benchmark and want the failures to produce something reusable, since the loop of proposing mutations, evaluating on held-out data and keeping what works is the whole point of the tool. Do not adopt it without a benchmark, because evolution without a benchmark is listed as an open research direction rather than a feature. Verify first which agent harness you have and its minimum CLI version, since the adapters list specific version requirements, and that your model provider is reachable, because the tool evaluates variants by running the agent for real.

## FAQ

### What is EvoSkill?

It is an open-source framework that automatically discovers and synthesises reusable agent skills from failed trajectories, to improve coding agent performance. It is compatible with Claude Code, Codex CLI, OpenCode, OpenHands, Goose and Harbor.

### Which agents does EvoSkill support and what do they require?

Claude Code needs nothing special, OpenCode requires CLI v1.4.0 or later for structured output, OpenHands has no native structured output and uses fallback JSON extraction, Goose requires CLI v1.25.0 or later with the summon extension, Codex CLI uses skill discovery through a `.agents/skills/` symlink, and Harbor is the containerised benchmark harness.

### How do I install EvoSkill?

Run `curl -fsSL https://raw.githubusercontent.com/sentient-agi/EvoSkill/main/install.sh | bash` for the one command install, or `./install.sh --agents claude,opencode` for specific agent CLIs. Manually it is `uv sync` or `pip install -e .`, with Python 3.12 or newer required.

### Can EvoSkill improve an agent without a benchmark?

Not yet. The feature table lists evolution without a benchmark, where benchmarks are generated on the fly, as an open research direction, and continuous evolution from regular usage is likewise marked as work in progress.

### What licence is EvoSkill released under?

The Apache 2.0 licence, with the licence file in the repository root. The current package version is 0.1.0, the latest release tag is v1.3.0 from 2026-06-16, and the last push to the main branch was on 2026-08-24.

## Sources

- [Issues](https://github.com/sentient-agi/EvoSkill/issues)
- [License: Apache-2.0](https://github.com/sentient-agi/EvoSkill/blob/main/LICENSE)
- [README](https://github.com/sentient-agi/EvoSkill/blob/main/README.md)
- [Releases](https://github.com/sentient-agi/EvoSkill/releases)
- [sentient-agi/EvoSkill on GitHub](https://github.com/sentient-agi/EvoSkill)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/sentient-agi-evoskill