An Impressive Open-Source Project: Are Agent Skills Starting to Self-Evolve?

Hello everyone, I’m CangHe.

Recently, I stumbled upon a very interesting open-source project on GitHub.

Making Agents Learn to Organize Skills on Their Own

This project is called OpenSquilla, and it has already garnered over 3700 Stars.

Its core focus is on the Harness layer optimization, reducing token costs through intelligent model routing.

The newly released MetaSkill 3.0 has pushed Agents from “being able to call tools” to “being able to self-organize skills and stably deliver workflows”.

To be honest, after reading its design philosophy, my first thought went to my own open-source product, WeSight.

WeSight’s positioning is to manage all Agents from a single entry point, while OpenSquilla’s positioning is the “self-organizing skill brain” for Agents.

One manages the entry and visualization, the other manages routing and skill orchestration.

Isn’t this a perfect match?

Well, I said, let’s get to work.

I directly integrated OpenSquilla as the engine into WeSight.

By selecting the OpenSquilla engine in WeSight, you can convert a WeChat public account article into Xiaohongshu (Little Red Book) graphics and text with just one sentence.

I have a pain point with content creation:

After writing a WeChat public account article, if I want to sync it to Xiaohongshu, I have to rewrite the title, change the copy, and create a cover image.

The whole process takes at least half an hour.

Can’t we just let the Agent handle this?

Hardcoding workflows is too rigid. What I want is for the Agent to discover what skills to use on its own, decide how to combine them, and complete the work by itself.

So I created a new task in WeSight, selected the OpenSquilla engine.

Then I only entered one sentence:

Help me convert this WeChat public account article into Xiaohongshu graphics and text, with a style that has a strong “grass-planting” feel.

Then I pasted the article link.

Next, OpenSquilla didn’t just blindly start working. Instead, it first searched through the available skills in the background.

It “discovered” three atomic skills in WeSight’s skill panel:

• wechat-article-extractor (parses WeChat public account articles)
• xiaohongshu-text-skill (generates Xiaohongshu copy)
• xiaohongshu-cover-generator (generates Xiaohongshu cover images)

Then, it assembled these three skills into a workflow based on their dependencies.

First parse, then rewrite, finally generate the image.

The DAG relationship is crystal clear.

Step 1: The WeChat public account article link parsing is complete, and the markdown file appears in the file panel.

It is saved as a markdown file:

Actually, it calls the wechat-article-extractor skill

Step 2: Based on the parsed markdown document, it rewrites the title and copy in a Xiaohongshu style.

Actually, it calls the xiaohongshu-text-skill

Step 3: Based on the overall style of the content, it calls gpt-image 2 to generate the cover image.

Actually, it calls the xiaohongshu-cover-generator skill

The entire process took about 40 seconds.

I checked the quality of the output.

The title had emojis, the copy was short with good internet-style feel, and the cover image style fit Xiaohongshu’s aesthetic.

It wasn’t 100% perfect, but as an automated result from a “one-sentence requirement”, it’s already quite impressive.

Even more crucial: This workflow wasn’t pre-written by me; it was assembled on the fly by OpenSquilla.

How Did It Do This?

This brings us to OpenSquilla’s MetaSkill protocol.

Traditional Agent workflows are either hardcoded scripts or manually dragged node graphs.

You have to tell it in advance: Step 1, do this; Step 2, do that; what to do if something fails.

But MetaSkill’s approach is completely different.

It’s a “meta-markdown” that essentially tells the model:

How to retrieve, filter, and combine atomic Skills.

For example, in the sidebar of WeSight just now, we could directly enter the OpenSquilla backend to see this meta-skill.

Clicking into the skill management interface, we could see the meta-skill we just created:

Clicking to view the details, as expected, it calls the three skills mentioned earlier.

In other words, it didn’t follow a hardcoded flow; it implemented a “protocol for organizing skills”.

In the case of converting a WeChat article to Xiaohongshu, the underlying MetaSkill looks like this:

You can see that there’s no specific business logic inside.

There are only step declarations, dependency relationships, and input/output mappings.

The actual “how to parse”, “how to rewrite”, and “how to generate images” are all delegated to the atomic Skills.

MetaSkill is only responsible for one thing: At the right time, string the right Skills together in the right order.

This brings a huge benefit:

When new Skills appear in the community, MetaSkill can automatically include them in the selection range without modifying the workflow itself.

For example, if a better “WeChat article parser” appears in the community one day, OpenSquilla will automatically discover it, evaluate it, and replace the old one when appropriate.

This is true “self-evolution”.

Why Is This Important?

I know what you might be thinking: Isn’t this just connecting a few tools? What’s so great about it?

Alright, let’s do the math.

Right now, various Agent frameworks, MCP tools, and open-source Skills are exploding in growth.

You might have Claude Code, Codex, OpenClaw installed locally, along with a bunch of MCPs, plus various custom Skills.

The number of skills quickly goes from dozens to hundreds, or even thousands.

Then the problem arises:

Do you know which of these 1000 skills can be combined to solve your current problem?

You probably don’t.

You’d have to comb through documents, try combinations, tweak parameters, and by the end you might forget what you were originally trying to do.

This is what OpenSquilla calls the “combinatorial catastrophe”.

What’s more, today’s skill combinations heavily rely on “expert experience”.

You need to know to call A first, then B; the output format of A must match the input format of B; if C fails, use D as a fallback.

All these constraints are written in people’s heads, or hardcoded into scripts.

Once the skill community updates, your script might become obsolete.

MetaSkill solves this problem.

It allows Agents to learn to organize skills like humans organize professional knowledge.

You don’t need to remember the capability boundaries of every skill, and you don’t need to manually assemble flowcharts.

You just describe the goal in natural language, and the Harness layer handles the rest.

This also leads to a more interesting judgment:

The next efficiency dividend for Agents may not come from model upgrades, but from Harness layer optimization.

No matter how strong the model is, if it can only work on one task after another in a brute-force manner, the cost won’t drop much.

What truly creates a gap is whether you can achieve “input reduction” at the skill organization layer.

Optimizing upfront at the skill composition level is much more effective than letting the Agent repeatedly trial-and-error online.

OpenSquilla’s intelligent routing follows this same philosophy:

Simple tasks use cheap models, complex tasks use good models, and cached results are reused directly.

For example, DeepSeek-v4-flash and DeepSeek-v4-pro are automatically selected based on task complexity. For complex tasks, OpenSquilla hands them off to the pro version.

MetaSkill builds on top of this routing, further automating workflow orchestration.

From the intelligent routing of 1.0 to the MetaSkill of 3.0, you can see a clear product roadmap.

Final Thoughts

After integrating OpenSquilla into WeSight, my biggest feeling is:

Agents are starting to seem human.

It’s not about whether they talk like humans; it’s about how they work like humans.

When faced with a new problem, they first check if they know how to do it. If not, they find information, organize it into a plan, and then execute.

This “self-organizing” ability is the key step for Agents to become truly practical.

Of course, OpenSquilla is not perfect yet.

For some complex workflows, its orchestration isn’t stable enough; for some skill dependencies, its judgment isn’t accurate enough.

But at least the direction is right.

Teaching Agents to build tools themselves is much more important than building more tools for Agents.

If you’re interested in this direction, you can search for OpenSquilla on GitHub, give it a Star to support the open-source community.

I’m also continuing to refine the integration experience between WeSight and OpenSquilla. I’ll share new developments with you later.

What do you think about the concept of Agents self-organizing skills? Feel free to discuss in the comments.

A good tool lets you think about one less thing.

The day Agents learn to organize skills on their own, we might truly only need to focus on the creativity itself.

Leave the rest to them.