# From 36% to 100%: How Self-Improving Agents Write Their Own Skills — Rafal Wilinski, Runlayer

Rafal Wilinski, Runlayer

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/u-o0sW9nwmk-from-36-100-self-improving-agents-write) · [Video](https://www.youtube.com/watch?v=u-o0sW9nwmk)

## From 36% to 100%: How Self-Improving Agents Write Their Own Skills

Rafal Wilinski explains how Runlayer turns agent traces into reusable playbooks, distributes them through MCP, and uses the resulting feedback loop to preserve company knowledge across sessions and models.

### Keep the solution after the session ends

[0:12](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=12s)

A hard problem gets solved, the session closes, and the next person starts from scratch. The missing artifact is often the useful part: the debugging steps, rejected approaches and reasoning that made the solution possible. Rafal Wilinski, founding engineer at Runlayer and previously a leader of Zapier’s agent work, opens with a practical ambition: make every successful investigation leave a playbook the rest of the company can use.

That ambition extends beyond one agent remembering its own work. An engineer, salesperson or lawyer who cracks a difficult problem can improve the next attempt by sharing the procedure. Automating that handoff creates the possibility of company-wide learning: one agent’s discovery becomes another agent’s starting point.

### Longer tasks make the starting trajectory more expensive

[2:00](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=120s)

A skill is a playbook an agent reads when its knowledge becomes relevant. It uses **progressive disclosure**: the client or harness initially sees a short description; when the agent identifies a useful match, it reads the full skill into its working context. The procedure can then change which actions the agent takes. Better models, prompts and tools remain other ways to improve an agent, but skills offer a direct way to supply knowledge at the moment it is needed.

The stakes grow as models become capable of longer, multistep work. Wilinski points to a task-horizon benchmark measuring how long agents can work independently while retaining a chance of completing the task. That word—chance—matters. A longer reasoning window also lets an agent spend hours and hundreds of tool calls pursuing a wrong hypothesis. Without a useful starting procedure, greater persistence can make a mistake more expensive.

The most valuable skills often contain what Wilinski calls “the rituals that nobody wants rediscovered.” These are local details that general model capability does not automatically supply:

- **Production rollback:** the sequence of scripts and feature flags needed to reverse a change safely.
- **Customer retention:** the wording and approach appropriate for an enterprise customer close to churning.

Both examples depend on how a particular company works. Asking an agent to reconstruct that knowledge on every attempt adds exploration precisely where mistakes can be costly.

![The slide presents a short skill description beside a fuller skill procedure.](https://ai.engineer/api/talk-essay-media/f53e1d69ea50e3c9fc07e1941b99e8dfb2c04cd0260fa5c83fc79e2b9cf4f29b)

The slide presents a short skill description beside a fuller skill procedure.

### Useful playbooks still need authors, access and trust

[5:01](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=301s)

Skills have three separate adoption problems. Solving one does not automatically solve the others:

- **Developer-oriented packaging:** Markdown, JSON, CLI commands and Git repositories are familiar to developers. They make creating and sharing skills harder for people in marketing, HR, legal or finance.
- **The cost of writing:** everyone likes finding an existing playbook, but producing one requires time and deliberate reflection after the difficult work is finished.
- **Uneven client support:** a useful skill cannot guide an agent if the employee’s LLM client has no way to discover or load it.

Installation introduces another practical concern. Wilinski jokes that a skill installer can bring along prompt injections, a script requiring root permissions and somebody else’s API key. The joke comes with a concrete observation: Runlayer scans thousands of skills every day and encounters suspicious content. A playbook influences the agent’s decisions, and its package may also include executable material. Making installation easy therefore increases the importance of checking what is being installed.

### Use MCP to deliver knowledge as well as capabilities

[7:27](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=447s)

Skills and MCP serve complementary purposes. A skill explains how to do something; a tool supplies the capability to do it. Putting a command or API key in a Markdown file does not remove the need to connect agents to systems. MCP can also carry the playbook itself, giving knowledge a shared distribution channel alongside tools.

In this design, clients connect to a remote MCP server and search for relevant skills instead of installing their own local copies. The server selects what to return using the query and policy, including the requester’s assigned role. A central source can supply the appropriate version of a procedure and give an AI adoption lead one place to manage the knowledge being shared. Wilinski reports that Runlayer had used this approach internally for six months.

The implementation choice is about client reach. The Skills over MCP working group was developing an API, with the specification direction leaning toward MCP resources. Runlayer chose tools because resource support was mixed. The API was not final at the time of the recording, and practical reach still depends on the client’s MCP support. Within that constraint, distributing skills through tools lets more employees retrieve procedures through the clients they already use.

Central distribution addresses access and governance. It still leaves the authoring problem: somebody has to turn an investigation into a useful skill. The next step is to let completed agent work supply the material.

![The diagram places an MCP gateway between client tools and several skills.](https://ai.engineer/api/talk-essay-media/705090e210d49d14134e77a7fbe10668553e9d6792bb46edb22ce66fc210dea1)

The diagram places an MCP gateway between client tools and several skills.

### Turn exploration into reusable procedural knowledge

[9:47](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=587s)

**Voyager**, the 2023 Minecraft agent work, provides the model for this kind of learning. In Wilinski’s account, the agent explored and pursued goals while accumulating a skill library, without changing the underlying model weights. When it discovered how to do something, it saved a code recipe containing the tool calls that accomplished it.

A later goal—making a crafting table or a diamond pickaxe—could then retrieve the recipe rather than reconstruct the procedure. The accumulating library changes what the agent has available for its next attempt. This is the idea Runlayer carries into workplace tasks: exploration should produce reusable procedural knowledge instead of ending as a discarded trace.

Runlayer lets agents perform real work, then takes an interesting successful run containing multiple tool calls and asks a frontier LLM to distill a skill from its trace. The saved artifact is a procedure for future work. Authoring happens after the run, asynchronously, rather than depending on someone remembering to write documentation.

Failures supply a different kind of information. A successful run demonstrates a route that worked; a failed run can expose a missing guardrail, an unavailable library or an overlooked edge case. Both feed the distiller. Successes support the existing procedure, while failures provide reasons to revise it. Wilinski describes this update loop as autonomous, without a human in the loop.

![The slide shows a skill library alongside a diagram of exploration and reusable knowledge.](https://ai.engineer/api/talk-essay-media/d40081dffec7011871946c7e3926bdd31fcbb77da184b87e27dfe94d9971dce9)

The slide shows a skill library alongside a diagram of exploration and reusable knowledge.

### A Chromium-on-Lambda task moves from rediscovery to reuse

[12:36](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=756s)

The concrete test was getting a Chromium fork to run inside AWS Lambda using **Sonnet 4.6**. The agent sometimes completed the task, but its initial success rate was 36%. Runlayer enabled its self-improvement mechanism. When one invocation solved the problem, the distiller generated a skill from that run and included it in all subsequent runs. Wilinski reports that the success rate rose to 100%. The slide below answers the immediate question: how many attempts sit behind those percentages? It labels the comparison a 25-run evaluation, showing 9/25 successes without the skill and 25/25 with it. The recording does not give the full evaluation protocol or contents of the skill, so this result describes the reported test rather than a general guarantee of reliability.

The comparison makes the observable change clear: occasional success became consistent success within the reported evaluation. Initially, separate invocations had to find a working route. One successful invocation supplied a trace; the distiller converted that trace into reusable instructions; later invocations received those instructions before attempting the task. The successful run stopped being an isolated event and became input to future behavior—“a developer with better attitude towards documentation,” as Wilinski puts it.

Why might the same change also reduce cost? A good skill narrows the search space. It steers the agent toward a known procedure, reducing the branches it explores and the tool calls it spends on rediscovery. Wilinski presents fewer tokens and lower spending as consequences of that mechanism; the numerical result here measures task success.

![The slide compares 36% success without a skill with 100% with a skill.](https://ai.engineer/api/talk-essay-media/c3ffe8bfc27bb61df9903401fce31f0007139c347809f81d35bc5e47ae76bd45)

The slide compares 36% success without a skill with 100% with a skill.

### Share the learning loop across the company

[13:59](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=839s)

There is another reason to retain procedures: access to frontier intelligence is rented. A provider can deprecate a model, and users may experience changes in its behavior. Wilinski’s response is to use capable models while they are available to discover and persist useful procedures. A catalog of how work gets done keeps something the company can carry forward when its model changes.

The organizational version combines three pieces already introduced: skills retain procedures, a central library stores them, and MCP distributes them. Runlayer groups similar runs, distills a candidate skill, and passes it through checks that include prompt injection and personally identifiable information. A skill that passes goes into the library and becomes available through the MCP gateway to clients and agents across the company.

**Runs → candidate skill → safety checks → shared library → MCP clients.** Each new attempt contributes traces, including failures that can reveal where the procedure needs to change. Checks happen before a skill becomes available to other agents.

The shared library is what extends learning beyond the original agent. When another employee’s agent encounters the same database restart or production rollback problem, it can retrieve the accumulated playbook. As more runs expose useful procedures and edge cases, the library can improve the starting point for subsequent work throughout the organization.

### The advantage is the knowledge accumulated in doing the work

[16:12](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=972s)

The ending turns to competitive advantage. If competing companies can access the same models and reproduce similar product interfaces, where does differentiation come from? Wilinski proposes the accumulated learning loop: governed procedures drawn from a company’s own hard-won experience. That is a strategic argument about the value of internal knowledge, rather than a demonstrated barrier to competition.

The proposed advantage has a practical form. Each solved problem can raise the starting point for the next person; each useful failure can add a missing restriction or edge case. Retained procedures can reduce repeated exploration without changing the model and preserve useful knowledge through model transitions. The company’s particular way of working—its internal culture and identity—becomes something agents can retrieve and apply, rather than something lost when a session closes.

## Key takeaways

- Skills use progressive disclosure: a short description helps an agent find relevant knowledge, then the full procedure enters its context to guide the attempt.
- MCP can distribute skills from a central server that selects procedures by query and role. Runlayer uses tools because MCP resource support is uneven.
- Successful traces supply reusable routes; failed traces expose missing guardrails, dependencies and edge cases that can improve the procedure.
- In the reported Chromium-on-AWS-Lambda evaluation using Sonnet 4.6, success rose from 9/25 runs (36%) without a skill to 25/25 (100%) with the distilled skill.
- Company-wide learning requires more than distillation: candidate skills pass checks, enter a shared library and reach future agents through the MCP gateway.

## Related talks

- [Beating RL With Reflection: GEPA and Optimize Anything](https://ai.engineer/talks/OA-Mc60Rboo-beating-rl-reflection-gepa-optimize-anything) — Develops the complementary optimization mechanism: use diagnostic execution traces to revise prompts, programs and repository skills, then evaluate candidates and preserve useful alternatives.

## Slides

### Self-Improving Agents That Teach the Company Back

Rafal Wilinski introduces a vision for combining self-improving agents with network effects so an entire company can improve.

[0:22](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=22s) [Title slide for Rafal Wilinski’s talk on self-improving agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/a496bfedbe0002a59fedb0fb78ae32bb70524d666fa7e8fc76e268d98fc9ace4.webp)

Self-Improving Agents That Teach the Company Back

Rafal Wilinski · Founding Engineer, Runlayer

Interface text:
Runlayer
AI ENGINEER WORLD'S FAIR 2026

### A Playbook for Everyone

Wilinski imagines automatically recording how people solve hard problems, so their teams can reuse the playbook when similar problems arise.

[0:35](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=35s) [A lawyer solves a hard problem and leaves a playbook for everyone.](https://assets.ai.engineer/sites/aiecode2025/sha256/8e3ea5a022ec0322628f5a16c52fc5c5f1ea5d3194b8b1a30cd775c5dea5fe4b.webp)

IMAGINE

Your best lawyer cracks the hard problem — and leaves the playbook for everyone.

Interface text:
Runlayer
01 / IMAGINE

### Reality Check

An illustrative chat shows how outage fixes can be lost: Rafal remembers flipping about three feature flags in a particular order, but cannot recall the order when staging hits the same problem.

[1:05](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=65s) [An illustrative chat shows engineers unable to recall the steps used to resolve an outage.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d7d1ce7e1d15dfbab783c3a8dc2dece10fa6b4c26be131e58f1c84d4d421d2d.webp)

REALITY CHECK

# eng-war-stories

Vitor Balocco 11:42 AM
dumb q — when checkout broke back in March, how'd we actually roll it back?

Rafal Wilinski 11:43 AM
ohh the great friday outage

Rafal Wilinski 11:43 AM
i flipped like 3 feature flags in a very specific order and it came back to life

Vitor Balocco 11:44 AM
which order?? staging's doing the exact same thing rn

Rafal Wilinski 11:44 AM
no clue man, it was 2am

Interface text:
Runlayer

### Reality Check

An illustrative chat shows debugging knowledge getting lost: Rafal recalls flipping about three feature flags to restore checkout, but cannot remember their order when staging has the same problem.

[1:22](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=82s) [An illustrative chat shows engineers unable to recall the steps used to resolve an outage.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d3cfbd0a17a35501ebf87466ed280991398b2fe8117001639308dc8216a7111.webp)

REALITY CHECK
Runlayer

# eng-war-stories

Vitor Balocco 11:42 AM
dumb q — when checkout broke back in March, how'd we actually roll it back?

Rafal Wilinski 11:43 AM
ohh the great friday outage

Rafal Wilinski 11:43 AM
i flipped like 3 feature flags in a very specific order and it came back to life

Vitor Balocco 11:44 AM
which order?? staging's doing the exact same thing rn

Rafal Wilinski 11:44 AM
no clue man, it was 2am

### Rafal Wilinski: Building Agents for Production

Rafal Wilinski describes his work as making agents reliable in production. He is a founding engineer at Runlayer and previously led Zapier Agents.

[1:36](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=96s) [Rafal Wilinski’s portrait accompanies a brief biography and statement about building production agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/1f9ae05746ea5257803b8beac0e222651703ffab91ba4db6675fd6f616e65961.webp)

RAFAL WILINSKI

I build agents that have to survive production.

Founding Engineer at Runlayer. Previously Tech Lead for Zapier Agents, AI Tech Lead at Vendr, and creator of Dynobase.

X.COM/RAFALWILINSKI

Bio source: rwilinski.ai

Interface text:
Runlayer
02 / AUTHOR

### Self-Improving Agents That Teach the Company Back

Wilinski begins with improving agents, focusing on skills as an accessible approach.

[1:59](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=119s) [Title slide with “Improving Agents” highlighted.](https://assets.ai.engineer/sites/aiecode2025/sha256/e8442c6b3109de05d4da0e4472853715c8b8e5ef270d30cfc99045e2314116a6.webp)

Self-Improving Agents That Teach the Company Back

Runlayer
03 / AI ENGINEER WORLD'S FAIR 2026

### A Skill Is a Playbook

The client first sees skill summaries. When a skill looks useful, it can load the full playbook into the agent’s context, where its instructions can change the agent’s trajectory.

[2:22](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=142s) [A selected skill moves from a list of summaries into an LLM context window.](https://assets.ai.engineer/sites/aiecode2025/sha256/dcf894c29a6d78686fa90861047bf249512aca60ea27b3c2faee43e05238513c.webp)

WORKING DEFINITION

Skill = a playbook an agent can load when the work starts.

AVAILABLE SKILLS · SUMMARIES ONLY
oncall-runbook
chromium-lambda
pr-review

LLM CONTEXT WINDOW
chromium-lambda
LOADED INTO CONTEXT

Interface text:
Runlayer
04 / TERM

### A Longer-Running Agent Can Dig a Deeper Hole

Longer task horizons give agents more time to pursue a wrong path. The diagram shows a trajectory spiraling into a rabbit hole; Wilinski argues that skills help guide the initial trajectory toward the right target.

[3:49](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=229s) [A path crosses a landscape and spirals into a deep rabbit hole.](https://assets.ai.engineer/sites/aiecode2025/sha256/73e81da836de081a29a5e01cb25ec38480024f54fa37609b2414945c9ce3c9b0.webp)

Runlayer
06 / DEEPER WRONG PATHS

THE HIDDEN COST

A longer-running agent can dig a much deeper hole.

More autonomy means more useful work, but also more time to over-invest in a local optimum.

Goal completion Z
Skill space X
local optimum
Rabbit hole

### Valuable Skills Preserve Company Rituals

Wilinski argues that agents need company playbooks for decisions such as rollback order, customer wording, and discount approvals; rediscovering them from scratch can lead to costly failures.

[4:30](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=270s) [Four examples cover rollbacks, revenue recognition, customer communications, and discount approvals.](https://assets.ai.engineer/sites/aiecode2025/sha256/5e1db946fbb9c529162a5f0725e1de33498760f62ea906b9005c9cec245a301b.webp)

WHY ENTERPRISES CARE

The valuable skills are the rituals nobody wants rediscovered.

“How do we roll this back safely?”
Which feature flags to flip, in what order, and what not to restart.

“How do we rec revenue on this deal?”
The multi-year schedule, the exception cases, who signs off.

“Can I send this to the customer?”
The escalation tone, safe wording, and who owns the reply.

“Who approves this discount?”
The approval ladder, the threshold, the redlines that are actually negotiable.

Interface text:
Runlayer
07 / ENTERPRISE EXAMPLES

### Skills Are Local-First and Developer-Centric

Skills use Markdown, JSON, CLIs and Git. Wilinski says this developer-centric ecosystem makes creating and sharing skills across nontechnical teams a challenge.

[5:16](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=316s) [A slide describes the challenge of sharing and updating skills across a company, alongside a social-media post.](https://assets.ai.engineer/sites/aiecode2025/sha256/09bc6c5f3b8a472edd9e6d058416dba133dc10f6513f8a2bbd8361bbe8820424.webp)

THE CURRENT ECOSYSTEM

PROBLEM #1:
Skills are local-first and dev-centric.

That is fine for developers. It breaks when a whole company needs shared, updated knowledge.

Hamel Husain
@HamelHusain

What’s the best way for non developers to

1. share skills with their team
2. automatically enforce that it’s always updated for everyone if changes are made
3 allow others to update it centrally

Github is not the best solution as it’s too clunky and doesn’t solve #2

Notion

6:03 AM · Jun 11, 2026

Reference: Hamel Husain on X

Interface text:
Runlayer
08 / ECOSYSTEM PROBLEM
Follow
Show more
167
Reply
Copy link
Read 79 replies

### Installing skills

A chimpanzee holds a rifle labeled “npx skills.” Wilinski jokes that installing skills can also bring prompt injections, scripts requiring root permissions, and someone else’s API key.

[6:04](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=364s) [A chimpanzee holds a rifle labeled with a skills installation command.](https://assets.ai.engineer/sites/aiecode2025/sha256/172c01fe437e44750fc72635ab6dfadb1e11eae8c103517abdd76ca414e5de10.webp)

npx skills

### The hand-authoring problem

Writing a playbook takes time and effort. One example is a Lambda runtime with a specific Chromium fork, font package, and launch flag that someone must document and maintain.

[6:34](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=394s) [A slide argues that hand-authored skills are difficult to maintain at scale, alongside an example of runtime setup details.](https://assets.ai.engineer/sites/aiecode2025/sha256/a6a45effa94dfbf10b0d91fb0dba759c22c2156debb7176c93662db95d7dc517.webp)

THE LAME PART

PROBLEM #2:

Nobody wants to create them.

Hand-authored skills are useful, but they do not scale to every weird task an agent discovers while doing real work.

Dear agent,
please remember that this one Lambda runtime
requires this one Chromium fork
and this one font package
and this one launch flag
and...

no human wants to maintain this forever

Interface text:
Runlayer
09 / HAND AUTHORING

### Client compatibility

The slide contrasts Claude Code’s native skill workflows with its stated lack of support in ChatGPT and uneven support across enterprise clients, a gap for non-developer teams.

[6:58](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=418s) [A slide contrasts skill support across Claude Code, ChatGPT, and enterprise clients.](https://assets.ai.engineer/sites/aiecode2025/sha256/5852ab816fb14b8a8271076cd0fe354b684d73c24244a3332a85b641ce385d6e.webp)

CLIENT COMPATIBILITY
PROBLEM #3:
Not every LLM client supports Skills.

Including the client your HR, marketing, and finance teams are most likely already using.

Claude Code
Great for developers. Native skill workflows fit the audience.
SKILLS

ChatGPT
The popular client for non-developer departments.
NO SKILLS

Enterprise clients
Mixed support, different surfaces, uneven rollout.
FRAGMENTED

Interface text:
Runlayer
10 / CLIENT GAP

### Skills over MCP

Wilinski argues that skills provide knowledge, while MCP provides tools and can also distribute skills. The slide frames this as an alternative to declaring MCP dead.

[7:26](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=446s) [A slide argues for skills over MCP alongside two public posts criticizing MCP.](https://assets.ai.engineer/sites/aiecode2025/sha256/586d1806f62cf3d6d1c17144632ba2a69cdc2d604c166ab759222ff999b33845.webp)

THE INTERNET ARGUMENT

“Skills vs MCP” is the wrong fight. Skills-over-MCP is the answer.

levelsio
@levelsio · Follow

Thank god MCP is dead

Just as useless of an idea as LLMs.txt was

It's all dumb abstractions that AI doesn't need because AIs are as smart as humans, so they can just use what was already there — which is APIs

Garry Tan
@garrytan · Follow

MCP sucks honestly

It eats too much context window and you have to toggle it on and off and the auth sucks

Sources: X posts by @levelsio and @garrytan

Interface text:
Runlayer
11 / DISCOURSE
View post on X
View post on X

### A remote source of truth for skills

AI clients connect to a remote MCP gateway to find and fetch skills from one library. The gateway also provides a governance layer; the speaker says it can enforce policies based on a user’s role.

[8:08](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=488s) [AI clients connect to an MCP gateway that serves a skills library and a governance layer.](https://assets.ai.engineer/sites/aiecode2025/sha256/785d4d4a494653240d921758129a609c59eb9e9dd977e54488e16934c52e0d9a.webp)

SKILLS OVER MCP

Make the remote MCP server the source of truth for skills.

AI CLIENTS
Claude Code
ChatGPT
Cursor
GitHub Copilot
Perplexity

MCP Gateway
FIND · FETCH · GOVERN
one remote source of truth

ONE LIBRARY · DOZENS OF SKILLS
deploy.md
lambda-setup.md
pr-review.md
oncall-triage.md
db-migrate.md
brand-voice.md
refund-flow.md
+ 44 more

GOVERNANCE LAYER
RBAC
Auditing
Analytics
Scanning

Source: github.com/modelcontextprotocol/experimental-ext-skills

Interface text:
Runlayer
12 / SKILLS OVER MCP

### Skills Over MCP Working Group repository

The Skills Over MCP Working Group is exploring skill discovery and distribution through MCP. The repository calls the work experimental; the speaker says the exact API is not final.

[8:42](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=522s) [A public GitHub repository page describes an experimental Skills Over MCP working group.](https://assets.ai.engineer/sites/aiecode2025/sha256/426aa52e0a15fdcbe2a8ec1d1a16e2f9d4f08bb10e9403e0f5ca579310d158cd.webp)

Skills Over MCP Working Group

⚠ Experimental — This repository is an incubation space for the Skills Over MCP Working Group. Contents are exploratory and do not represent official MCP specifications or recommendations.

Charter: modelcontextprotocol.io/community/skills-over-mcp/charter — mission, scope, membership, active work

About
Experimental exploration of skills discovery and distribution through MCP primitives. Maintained by the Skills Over MCP Working Group.

Interface text:
Platform  Solutions  Resources  Open Source  Enterprise  Pricing
Search or jump to...  Sign in  Sign up
modelcontextprotocol / experimental-ext-skills  Public
Notifications  Fork 18  Star 143
Code  Issues 19  Pull requests 9  Actions  Projects  Models  Security and quality  Insights
main  49 Branches  0 Tags  Go to file  Code
olaservo  docs: reinstate digest field in skill://index.json for caching an...  7bf5c7d · 5 days ago  71 Commits
.github  docs: transition from Interest Group to Working Group (#81)  2 months ago
docs  docs: reinstate digest field in skill://index.json for cac...  5 days ago
.gitignore  Add .gitignore to exclude local settings file  4 months ago
CONTRIBUTING.md  docs: transition from Interest Group to Working Group (#81)  2 months ago
LICENSE  Add Creative Commons license for project documentation  4 months ago
README.md  docs: link SEP-2640 across repo and tidy Related Work ta...  2 months ago
README  Code of conduct  Contributing  Apache-2.0 license  Security
Readme  Apache-2.0 license  Code of conduct  Contributing  Security policy  Activity  Custom properties
143 stars  19 watching  18 forks
Report repository
Releases
No releases published
Packages

### Two functions for finding and retrieving skills

Runlayer uses MCP tools to search for skills and fetch a skill file; the speaker cites mixed resource support. Ranking, scoping, governance, and evaluation remain the harder work.

[8:56](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=536s) [Slide shows functions for searching skills and fetching a skill file, with governance and evaluation identified as harder problems.](https://assets.ai.engineer/sites/aiecode2025/sha256/c5cfcae0cb996ae28592935115e57445ed5c66cfa970bae8e1b9effcc3ea1bca.webp)

TECHNICALLY SIMPLE

Two functions get you surprisingly far.

Search for relevant skills. Fetch the actual skill file. The harder work is ranking, scoping, governance, and evaluation.

findSkills({
  query: "debug chromium lambda fork"
}) → SkillSummary[]

getSkillFile({
  skillName: "chromium-lambda-runtime",
  fileName: "SKILL.md"
}) → string

Interface text:
Runlayer
14 / API

### Client compatibility with skills and MCP

The slide marks MCP support across four clients, while only Claude has native Skills. Wilinski presents MCP as a way to distribute skills to non-developer clients.

[9:07](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=547s) [Table compares skills and MCP support across ChatGPT, Claude, Microsoft 365 Copilot, and Google Gemini.](https://assets.ai.engineer/sites/aiecode2025/sha256/ae6afccc5c9b0be879f99e0ededa36a6f5fe317614aff2206594d70cb550c4a7.webp)

CLIENT COMPATIBILITY

Not every AI client supports skills. Many do support MCP.

CONSUMER CLIENT | SKILLS | MCP | REALITY
ChatGPT | ○ | ● | MCP works through ChatGPT Apps/custom connectors; no native Skills surface in regular ChatGPT.
Claude | ● | ● | Claude is the exception: Skills and MCP both exist in the Claude ecosystem.
Microsoft 365 Copilot | ○ | ● | MCP Apps are available in Copilot chat; no portable Skills format for end users.
Google Gemini | ○ | ● | Custom/remote MCP via Gemini Enterprise & Workspace connectors and the API; consumer app adds curated partner connectors. No portable Skills format.

● NATIVE
◐ PARTIAL / GATED
○ NOT DOCUMENTED

Sources: OpenAI, Anthropic, Microsoft, Google docs

Interface text:
Runlayer
15 / COMPATIBILITY

### Exploration becomes reusable procedural knowledge

Voyager saves Minecraft discoveries as code recipes. It verifies new skills, adds them to a library, and retrieves them for later tasks.

[10:44](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=644s) [Voyager diagram connects an automatic curriculum, iterative prompting, an environment, self-verification, and a skill library.](https://assets.ai.engineer/sites/aiecode2025/sha256/c158d4457024e786045e3f829788f70bc2415cdc2aac60a9cf62232ae791cdc7.webp)

THE MECHANISM
Exploration becomes reusable procedural knowledge.

Automatic Curriculum
Mine Wood Log
Make Crafting Table
Combat Zombie
Mine Diamond
New Task
Update Exploration Progress

Iterative Prompting Mechanism
async function combatZombie(bot) {
  // Equip a weapon
  const sword = bot.inventory.findInventoryItem(
    mcData.itemsByName["stone_sword"].id);
  if (sword) {
    await bot.equip(sword, "hand");}
  else {
    await craftStoneSword(bot);}
  // Craft and equip a shield
  await craftShield(bot);
  ...
}
Env Feedback
Execution Errors
Code as Actions
Environment
Self-Verification
Refine Program
Add New Skill
Skill Retrieval

Skill Library
Mine Wood Log
Make Crafting Table
Craft Stone Sword
Make Furnace
Craft Shield
Cook Steak
Combat Zombie

Figure 2: VOYAGER consists of three key components: an automatic curriculum for open-ended exploration, a skill library for increasingly complex behaviors, and an iterative prompting mechanism that uses code as action space.

Interface text:
Runlayer
18 / SKILL LIBRARY
MINECRAFT

### Distill a successful run into a skill

Runlayer uses a frontier LLM to distill the trace of a successful run into a private skill; the next run loads it.

[11:35](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=695s) [Four-step loop traces a successful run, distills its reusable part, drafts a private skill, and loads it in a later run.](https://assets.ai.engineer/sites/aiecode2025/sha256/0be8a94be414c919b4870f850dcdb7493190b88ee4d9d64b12f67f8475ba2b98.webp)

THE LEARNING LOOP

Take the successful run. Distill the reusable part. Draft a skill.

1 TRACE
A successful run

2 DISTILL
the reusable part

3 DRAFT
M↓ Private skill

4 REUSE
Next run loads it

Interface text:
Runlayer
19 / DISTILL

### Every run can improve a skill

Successful and failed runs feed a distiller that sends a revised skill back to the agent. Failures can reveal missing guardrails, libraries or edge cases; successes help validate the skill.

[11:54](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=714s) [Successful and failed agent runs feed a skill distiller, which returns a revised skill to the agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/694756c6fb7f9b98808fa5ce98493d3dd28ba5a1a6de5d35646a3b6bc2eb7a74.webp)

SELF-IMPROVEMENT

Every run — pass or fail — distills a sharper skill.

AGENT
skill v1

✕ run a3f9c2e1
✓ run 7b1d04aa
✕ run c2e8f5b0
✕ run 9d4a1c77

SKILL DISTILLER
skill v2

NEW REVISION → AGENT

Successes and failures both feed the distiller — which ships the next revision of the skill straight back to the agent.

Interface text:
Runlayer
20 / ITERATION

### Chromium on AWS Lambda: reported skill results

In a 25-run evaluation using Sonnet 4.6, Chromium on AWS Lambda succeeded 9/25 times without a skill and 25/25 with one. The distilled skill captured the runtime setup and verification path.

[12:50](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=770s) [A 25-run comparison reports 36% success without the skill and 100% with it, using the same model.](https://assets.ai.engineer/sites/aiecode2025/sha256/5464b0a7fc9e3aac3d2513b472cafd27cb29499457efb3222cf889ae647f49a7.webp)

PRODUCTION ANECDOTE

Running Chromium inside AWS Lambda using Sonnet 4.6.

25-RUN EVAL · SAME MODEL

The distilled skill captured the exact runtime setup, launch flags, dependencies, and verification path that made future runs reliable.

SUCCESS RATE, SAME MODEL
36% — WITHOUT SKILL · 9/25
100% — WITH SKILL · 25/25

Not from a new frontier model. From a better playbook.

Interface text:
Runlayer
21 / RESULT

### A skill narrows the search space

A skill narrows the agent’s search space, reducing tool calls and token use as it explores fewer branches. The slide also depicts fewer failed tries and shorter wall-clock time.

[13:35](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=815s) [A chart compares failed tries, tool calls, tokens and wall-clock time with and without a skill.](https://assets.ai.engineer/sites/aiecode2025/sha256/7bd759aaa93462d464b82bcc8b009a1d829ab275f21b59d35937da741cfbc073.webp)

WHERE THE SAVINGS COME FROM

A skill narrows the search space before the agent starts spending.

Legend: WITHOUT SKILL; WITH SKILL
FAILED TRIES: 0
TOOL CALLS: ↓
TOKENS: ↓
WALL CLOCK: ↓

Less rediscovery.
Fewer wrong branches.
Rented intelligence becomes owned knowledge.

Interface text:
Runlayer
22 / SAVINGS

### What does the company retain?

Wilinski argues that skills preserve useful procedures when access to a frontier model changes, building a company catalog from work done with borrowed intelligence.

[13:58](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=838s) [The slide argues that distilled skills retain procedures when access to a model changes, alongside an embedded social post.](https://assets.ai.engineer/sites/aiecode2025/sha256/f859c1279762188df35526a20b42debce09e494e10fa7286a900c18d8d2eec9b.webp)

WHY NOW

The question is not just “can agents do it?” It is “what does the company retain?”

Frontier intelligence is borrowed. A model can vanish overnight — Fable 5 just got pulled. What survives the next swap is the procedure you distilled into a skill while you still had access.

shadcn
@shadcn · Follow

In light of what happened, I'm doubling down on skills like /improve.

A frontier model got pulled. If it happened once, it's gonna happen again. Fable today, 4.9 tomorrow or maybe gpt 6 one day.

So, treat intelligence as borrowed. Drain intelligence when it's available.

Reference: shadcn on X

Interface text:
Runlayer
23 / WHY NOW
View post on X

### Self-improving agents that teach the company back

Skills retain procedures, MCP distributes them, and a central repository collects updates for agents and clients across the company.

[14:41](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=881s) [White section title on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/a93660246158e413c61d45e75b66f64ebf4750e5073d207e5d5f4f40b6409d7d.webp)

Self-Improving Agents That
Teach the Company Back

Interface text:
Runlayer
24 / TEACH THE COMPANY BACK

### Self-improving organization flywheel

Runlayer distills similar agent runs into skills, checks them, and adds them to a governed library. MCP serves those skills to clients, so other agents can reuse what one agent learned.

[15:24](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=924s) [A diagram connects agent work, skill distillation, a governed organizational skill library and distribution to clients.](https://assets.ai.engineer/sites/aiecode2025/sha256/d56f4549d8b918596538dffc231e08668ea0f62f2b6bed5beed334ee100f1808.webp)

Runlayer
25 / FLYWHEEL

PUTTING IT TOGETHER
Self-improving organization flywheel.

1
WORK
Any agent, any client

2
DISTILL
Writes a skill back

WRITE

Org skill library
GOVERNED · VERSIONED

3
GOVERNANCE LAYER
RBAC
Auditing
Analytics
Scanning
Human in the loop

4
SERVE
MCP → every client

SERVE

## Full transcript

[0:12](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=12s) Hi, everyone. I'm Rafal. Today, I wanna talk about self-improving agents, but not in a single player mode where just one agent gets smarter. I wanna talk about how we can apply that concept and mix it with network effects to get a self-improving company or maybe even, uh, an enterprise that self-improves while you sleep.

[0:35](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=35s) Um, imagine the best engineer you ever worked with, or a salesperson, or a lawyer. Um, the one that every time they cracked a genuinely hard problem, they wrote down exactly how they did that and handed over the playbook to the team. So whenever they face a similar problem, they don't have to figure it out from the scratch, right? And imagine that happening for every hard problem across your whole company, and that happening automatically, uh, each time. That's a dream, right?

[1:06](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=66s) But it almost never works that way. Um, even when you crack a really hard problem, um, oftentimes the knowledge, um, all that debugging, um, all the, all the reasoning behind that is just gone. Oh, sorry. Um, all that, uh, all that reasoning is just gone when you move on to the next, the next task or close the session. But I wanted to convince you that this is actually possible, and we already have all the primitives in place to make it happen.

[1:37](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=97s) If it sounds interesting, let me intro- introduce myself once again. Hi, I'm Rafal. I'm a founding engineer at Runlayer. We are making the golden path for AI at your company. Um, before that, I was leading Zapier agents and different AI teams, but generally speaking, my previous work was about making agents not just flashy demos, but reliable things in production.

[2:00](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=120s) Um, before we go into interesting parts, I wanna break down my topic into three separate pieces and start by just improving agents. There are many ways to do that. We can use better models. We can use better prompting tools, harnesses and whatnot. But I wanna focus today only just on skills because they are super accessible, right? At least in theory. Um, to make sure that we are on the same page, a skill to me is a playbook that essentially agent can read, um, when it thinks that the knowledge is

[2:30](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=150s) relevant. From the technical perspective, the, the term is called progressive disclosure, and it means that at the very beginning, the harness or a client sees just a summary of the skill or a short description of the skill. But when it thinks that the knowledge inside the skill can be useful, it can read the whole of the skill, inject it to the main context, and based on that knowledge, it can change the trajectory of the agent. Why is this so important? Well, if you haven't been living under a rock for the past

[3:00](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=180s) six or twelve months, your workload probably has changed a lot, uh, and that's because the agents got so much better. Actually, the models got so much better. And, and it's not just vibes. It's measurable. Um, here you can see a chart that probably you have seen too many times already. For those who don't know, it's METER benchmark. It measures for how long agents can work independently while still having a decent chance of completing a task. And the word chance is essential here. Um, we are

[3:30](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=210s) going to go back to it in a moment. But the trend is clear. The frontier capabilities, the frontier intelligence is getting better and better. They are better at multi-step deep work. There's only one caveat if that frontier intelligence is not being taken from you, and I'm as fabled probably just like you.

[3:50](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=230s) But there is a catch. With great power or long task horizon comes great responsibility. If an agent can reason for much longer, it also means that it can dig a really, really, uh, deep rabbit hole. Um, it can spend hundreds of tool calls trying to defend a wrong thesis, reason for hours. The next agent can do exactly the same thing or maybe even do something wrong, um, worse. Um, so the initial trajectory matters a lot, and that's why skills are so

[4:20](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=260s) important because they guide the agent towards the right target. Otherwise, you'll waste time, you'll waste tokens, and most importantly, you'll also waste money.

[4:31](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=271s) Um, valuable skills are the rituals that nobody wants rediscovered. That knowledge is often not glamorous. It's probably deeply embedded within your company. And if agents would try to rediscover that knowledge from scratch, like for instance, the sequence of scripts and feature flags in order to make a nice rollback, or what's the exact wording and language to use when dealing with that pesky es- uh, enterprise customer that's about to churn. Um, yeah, if agents would try to figure out that from

[5:01](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=301s) scratch, they are likely going to fail, and oftentimes that failure can be really costly. That's why I believe so many AIPs or POCs are failing because you're not giving agents the relevant context and the playbooks how to act within your company. So skills are great, but I feel like they are not problem-free. Um, there are three most important problems, and the first one is that they are local first and dev-centric. What I mean by that is that, um, when you

[5:31](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=331s) look at the skills ecosystem, you're going to find, um, Markdown files, JSON files, CLI commands, Git repositories, and if you're a developer, that's great. But if you're, um, ado- uh, VP of AI or AI adoption lead, you need to think more empathetically about how you can roll out the AI strategy across your whole company, which includes non-technical people, right? And the challenge here is how non-technical people can actually create and share, uh, the

[6:01](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=361s) skills. Uh, I love this meme. Um, this is the junior developer or a non-technical person discovering command ex- npx skills, which is the most important, but the most popular command to install them. That's the only command I know that installs just, uh, not just the skill, but also free prompt injections, um, a wild script that requires root permissions, and someone else's API key all in one run. Trust me, at Runlayer, we are scanning thousands of skills every day, and

[6:31](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=391s) there is really weird stuff inside. Okay. Second problem is that I think we all like-- we all love the situation where we are facing a hard problem, and there's already playbook on how to deal with that situation, right? But oftentimes there's, there's no playbook, right? Because it time- it takes time, and effort, and intention, and energy to reflect on a problem and leave something useful for posterity behind. And the third problem is that not every

[7:01](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=421s) LLM client supports skills, right? If you're in cloud ecosystem, it's probably great. If you're a developer, you're probably going to manage, even if the skills support is weird, depending on which client you're using. Um, and once again, if you think about marketing, HR, legal, finance, those departments are probably still using ChatGPT or some other weird LLM client, and skills might be not supported there.

[7:27](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=447s) And some time ago, there was this big heated debate when the skills were introduced. Um, some people proclaimed that, "Thank God MCP is finally dead because I'm not interested in dealing with OAuth. I can now hard code a bunch of CLI commands, um, hard code my API key inside Markdown file and call it a progress," right? Um, but I think everyone missed the point. Skills can be delivering, um, the knowledge how to do something, and tools gives us capabilities. Tools from MCPs give us capability to do those things. But

[7:58](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=478s) MCP can be also used as a protocol to deliver the knowledge, to deliver the skills. We can use MCP as the distribution layer. So instead of installing skills locally, you can create a remote MCP server, which can become the source of truth across your whole company. Clients can connect to that. They can ser- they can search for the right skills. Uh, server can enforce the policy and make sure that everyone gets the best version of the skill possible, depending on the query and, for instance, the role that they

[8:28](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=508s) have assigned. We've been doing that internally at Runlayer for the past six months, and it's been working quite well. Um, but it's no longer just an internal thing. We see that the broader MCP ecosystem is also going that direction. Um, there's already a working group called Skills over MCP, and while the exact API is not final, direction is clear. MCP can be used to deliver the skills, to deliver the knowledge across your whole company.

[8:57](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=537s) Um, yeah, and while the official spec is leaning towards MCP resources, the support for resources is also mixed, so we are going with tools. Um, and yeah, if you remember the problem, the first problem I mentioned and the third problem I mentioned, which is, um, the problem that they are dev-centric and the lack of, uh, support for clients, MCP as a distribution layer fixes that because it's unified and on-- and works in almost every single client, not just developer

[9:27](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=567s) clients. So the problem of devel- of distributing skills to non-technical people is essentially solved, right? Plus, you have now a centralized API, so as a VP of AI or, like, AI adoption lead, you have one place to govern and manage what's the knowledge that's getting shared and distributed across your company.

[9:47](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=587s) Okay, so now we know how we can improve agents because we have, um, skills. We know that we can use MCP to distribute those skills across all the clients and agents. But let's talk about something more interesting, which is how agents can improve themselves. And whenever I, uh, see a new paper or a framework speaking about this topic, I always go back to, um, Voyager paper. Unfortunately, you cannot see the video, but it's Minecraft gameplay in, in background. So in, in twenty

[10:16](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=616s) twenty-three, right after GPT-4 was released, so ages ago, the question was: For how long multiple agents or harnesses can explore Minecraft space, right? Um, they dropped the agent into Minecraft with no instructions. They set its own goals. Agent just kept getting better without even touching the weights or, or model and the prompts. And in twenty twenty-three, I think that was pretty groundbreaking. How did they pull it off? Um, the key thing to

[10:46](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=646s) notice here is the skill library. So Voyager did not just explore the Minecraft space care- carefully and throw the trace away. When the agent figured out something, um, it saved the recipe as a code that, uh, that consisted of the tool calls that lead it-- that lead the agent to the discovery. So later on, when the agent decided that, hey, I need to create a, a crafting table or a diamond pickaxe, it didn't have to figure it out this whole knowledge from scratch. It could

[11:16](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=676s) simply go to the skill, uh, library and retrieve it as a code, as a recipe, um, that can be reused. And this is really important. This is the core idea that I wanna carry forward, is that, um, exploration should be turned into reusable procedural knowledge.

[11:36](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=696s) And we started doing something very similar at Runlayer. Um, we let the agents do the real work, and when the run succeeds and when there is something interesting in this run, there's multiple tool calls, um, we just take the trace, and we ask Frontier LLM to simply distill a skill, right? And while it's super simple to distill a skill from a single run, um, I think we humans and agents learn the most from mistakes, right? The real

[12:06](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=726s) sharpening happens when the agent fails. Um- So a run that would go sideways is actually the richest signal that you can get because it exposes the missing guardrail, the missing library, some kind of edge case that you haven't thought about upfront. Um, and every run or, or pass or fail just feeds our distiller mechanism, constantly making our skill better. Um, the successes are making the skill more trustworthy because if the agent achieved the goal, it

[12:36](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=756s) means that, hey, this skill works, and if it doesn't, it actually makes skill the more robust because now we know what's missing in here, and it all happens completely autonomously, asynchronously without human in loop. And the initial results were great. Uh, we had, uh, this task of trying to run some Chromium fork inside AWS Lambda, and we were trying to do that using Sonnet four point six, so not the most intelligent model, but sometimes it succeeded. Um, but

[13:06](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=786s) it was just, you know, it's not production ready to have thirty-six percent success rate. Um, so what we did is we flipped the flag for self-improving agents, um, and once in one run, the... one of the agent invocations cracked the code, our skill distiller create a reasonable skill. It was, uh, then included in all the future runs, and the success ratio went to one hundred percent. So yeah, that's great. It's like a developer with better attitude towards documentation.  Um,

[13:36](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=816s) the success rate is the easiest number to show, but good skill is narrowing the search space. It makes the agent...  Uh, it narrows the search space, and agents starts doing, um, stops doing tool calls, and it's exploring less branches. It's wa- it's wasting less tokens and, and less money.

[13:59](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=839s) But putting savings and accuracy aside, I think there's also a deeper reason why you should be distilling skills. Um, the problem is that frontier intelligence is rented or borrowed. It can disappear. I think, yeah, we all miss Fable. It was a great model, right? It can deprecate it, or it can get dumber. Like, we complain every single day on Twitter, on Slack that Opus is really dumb today, right? So while we have the access to the best version of that intelligence, we should be using that

[14:29](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=869s) to discover and persist those use- useful procedures. We should be building a catalog of how the works gets done inside our company as a collective subconscious.

[14:42](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=882s) And how we do it? Well, I believe we already have all the pieces of the puzzle here. Um, we have skills as a way to retain procedures and improve agents and guide models. We have MCP as a unified distribution layer for those skills, and you also have a central repository, the knowledge base for all of those skills, which is constantly being updated and fed with new data. Um, yeah, we also have the continuous learning flywheel for one

[15:12](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=912s) agent, but what's interesting is what I promised you at the very beginning, the network effect. Um, so what happens when you multiply that by every agent and every single client in the entire company? At Runlayer, we call it self-improving organizational flywheel. Um, we group a bunch of similar runs and try to distill a skill. It passes through our various series of checks, like whether it's not containing some kind of prompt injection or maybe PII, um, and bunch of other

[15:42](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=942s) stuff. Once it's good, it's landing in our skill library, and thanks to our MCP gateway, it's being served to each and every client and agent within the company. What we end up having is a constantly evolving knowledge base, which is always up to date, continuously updated with new alpha, fed with new edge, uh, edge cases. So once one agent figure out a really hard problem, it's getting dist- it, it's being distilled into a skill persistent in all organ- organizational library, library.

[16:12](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=972s) So whenever someone else, um, has the same problem in the future, they don't have to figure out the solution from scratch. They don't have to know, uh, what's the exact sequence of this magical commands that are going to restart the database or roll back the production. They can simply, um, reach out to the playbook they have. And why is this so important? Because I believe, like, fifty percent of us probably already had an existential crisis thanks to the models, and

[16:42](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=1002s) the thinking goes along the lines of, uh, okay, so models are becoming commodity. Everyone here has access to them. Um, cost of software is going to zero. Everyone is... can be rebuilding my product, um, at least on the surface. In fact, so many people are working today across the expo, and they are thinking, "Hey, everyone's building the same thing, right? So what is my moat?" Um, and I believe the moat can be in building this flywheel

[17:13](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=1033s) and distilling the knowledge to this flywheel because it's like your own hard-won lessons distilled, governed of how your company, uh, does things, you know. And it's captured, compounding, raising the floor for everyone across the company, giving them access to the best knowledge available. Um, it is also a way to be resistant against model intelligence deprecation, and it's a great way to lower your costs without ever changing a

[17:43](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=1063s) model. So yeah, that's probably one thing that competitor can't copy, your internal culture and your identity.

[17:53](https://www.youtube.com/watch?v=u-o0sW9nwmk&t=1073s) And yeah, that's pretty much it. Uh, thank you for coming. If it resonated with you, uh, I'm Rafal. I'm working at Runlayer. We are figuring out the AI golden path for you. I'm open to talk about skills, MCP agents, whatnot, and this is exactly what we are building at Runlayer. Thank you.
