Skill Evolution logo

Skill Evolution

Community
coco-research
skill-evolution

Use when running, reviewing or changing coco's self-evolution cycle: the 30-day loop that observes how skills are actually used, proposes evidence-backed edits to them as one branch and one pull request, and lands nothing without the owner's merge. Also use when asked why a skill changed, what the loop would propose next, or how to reject a proposal so it is not raised again.

Overview

Publishercoco-research
Repositorycoco
Skill nameskill-evolution
Stars
550
Forks
12
Bundled files
4
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 4 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by coco-research on GitHub. Read the source before you install it.

Installation

Install the Skill Evolution AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/coco-research/coco/tree/main/skills/skill-evolution
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/coco-research/coco.git /tmp/coco
mkdir -p .claude/skills
cp -r /tmp/coco/skills/skill-evolution .claude/skills/skill-evolution
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Skill Evolution in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Skill Evolution on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Skill Evolution is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Skill Evolution

A cycle that improves this repository's own skills from observed use, and proposes every change for a human to merge. It never writes to main and never merges.

Status: the scripts this file documents, scripts/evolve.py and the steps it runs, are not on main yet, so the commands below do not run today. They land with plan tasks 2 to 9 in .metagpt/plan.md: task 2 ledger.py through task 8 evolve.py, and task 9 run_fixtures.sh with the CI join.

The one rule

The loop proposes. The owner decides. There is no confidence level, budget or green gate that lets it land a change on its own. This is a design invariant, not a setting: a system that edits the repository that measures it has no natural stopping point.

What a cycle does

Five steps, and only the second one calls a model.

StepScriptModel?Output
1. Observescripts/observe.pynosignals/<cycle>.json, pinned to one commit
2. Proposescripts/propose.pyyes, one laneproposals/<id>.json and proposals/<id>.patch
3. Validatescripts/validate.pynoaccept or refuse, with a reason
4. Openscripts/evolve.pynoone branch, one pull request
5. Recordscripts/ledger.pynoa ledger row per event, and CYCLE.md

Run it:

python3 scripts/evolve.py run --window 30d            # the real cycle, needs credentials
python3 scripts/evolve.py run --window 30d --dry-run   # stops before opening a branch
python3 scripts/evolve.py run --window 30d --lane stub # no network at all
python3 scripts/evolve.py status                       # last cycle, open proposals

What the guard refuses

validate.py is the only thing standing between a model's output and a branch. It refuses, with the reason named, when any of these hold:

  • Out of scope. v1 may change a skill's description frontmatter, its references/ and its SKILL.md prose, and may add or remove example blocks. A persona file, a command file, a count file, a workflow or this skill's own scripts are all out of bounds.
  • An unresolvable citation. Every proposal cites its evidence by file and line, or by receipt id, and the citation must resolve at the pinned commit.
  • Over a cap. Proposals per cycle and diff size per proposal are both capped in references/lanes.json. A cycle that hits the cap states the remainder rather than truncating silently.
  • Already rejected. A diff whose hash a ledger row rejected inside the two cycle window is not proposed again.
  • A count that moved alone. If a proposal changes a published number, the coupled files must move with it, checked by running the repository's own checkers rather than a private copy of their rules. See docs/rules.md R7.

Exit codes

Three valued, like every gate in this repository: 0 pass, 1 blocked by a guard, 2 unrunnable or unmeasured. An empty cycle is exit 0 with nothing to propose, which is a valid result and not a failure.

Cost

Every model call goes through scripts/lane.py, which reads references/lanes.json, checks the cycle budget before spending, obeys the model routing policy, and records the lane id and token count on the proposal it produced. The expensive review lane refuses unless the owner has explicitly authorised it for that cycle.

Where things live

  • references/lanes.json - the allowed lanes and their budgets.
  • references/proposal-schema.json - the proposal shape, and the only fields a proposal may carry.
  • references/signal-sources.md - what observe.py reads and what it deliberately does not.
  • state/ledger.jsonl - the committed ledger. Append only. One record per event, and the record of why something was rejected is the part that matters.
  • state/CYCLE.md - the rendered human artifact for the most recent cycle.

Testing

bash scripts/run_fixtures.sh runs every suite and prints N/N passed. Every case uses the stub lane, so the suite needs no network and no model. CI runs the same command, so a proposal pipeline that stops working fails the build rather than shipping quietly.

Changing this skill

Changing the loop's own scripts is out of scope for a loop proposal by design, which means a change here is an ordinary pull request from a human or an agent working under review. If a change alters a rule in this file, say so in the PR title and update docs/rules.md in the same commit.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Skill Evolution AI skill do?

Use when running, reviewing or changing coco's self-evolution cycle: the 30-day loop that observes how skills are actually used, proposes evidence-backed edits to them as one branch and one pull request, and lands nothing without the owner's merge. Also use when asked why a skill changed, what the loop would propose next, or how to reject a proposal so it is not raised again.

Why use Skill Evolution on TypingMind?

Because you install it once and use it with any model. Skill Evolution is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Skill Evolution in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/coco-research/coco/tree/main/skills/skill-evolution. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Skill Evolution?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Skill Evolution?

As many as you like. As long as a model supports skills, you can use Skill Evolution with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Skill Evolution AI skill free?

It is published on GitHub by coco-research. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇