Here's a frustrating pattern. You spend forty minutes with an AI agent figuring out a gnarly problem — say, the exact incantation to get Stripe webhooks verifying signatures correctly behind your reverse proxy. You solve it. It works. You move on.

Three weeks later, on a different feature, you hit the same wall. The agent has no memory of last time. It starts from zero. You both rediscover the same solution, burning the same forty minutes.

The agent didn't learn anything. It never does.

Elyra v0.9.0 changes that. The agent can now save a hard-won solution as a reusable skill — so the next session starts from what the last one figured out.

The idea

This is borrowed from an idea floating around the agent community: when an agent solves something difficult, it should write down what it learned in a form it can use later. Hermes Agent calls them skill files. The principle is simple — an agent that writes its own playbook gets more capable the longer you use it.

Elyra already had skills: markdown files with a bit of frontmatter that teach the agent how to do something. Until now, you had to write them yourself. v0.9.0 lets the agent write its own.

How it works

When the agent solves a genuinely hard, non-obvious problem, it calls a new skill_write tool on its own initiative. You see a prompt:

─────────────────────────────────────────────
 Elyra learned something. Save it as a reusable skill?
stripe-webhook-signature-verification (project)
Use when verifying Stripe webhook signatures behind a proxy.
> Save skill
Discard
¶↑↓ navigate • Enter to confirm • Esc to discard
─────────────────────────────────────────────

Approve it, and a SKILL.md lands in your skills directory. Next session, the agent already knows how to do this — it reads the skill's description and loads the full instructions when relevant.

Discard it, and nothing is written. You stay in control.

A real example

Say you've been wrestling with a deployment quirk. After some trial and error, the agent figures out that your app needs a specific health-check grace period or the load balancer kills it mid-boot. It saves:

---
name: railway-healthcheck-grace-period
description: Use when deploying this app to Railway and the
load balancer kills the container during boot.
¶Railway Health-Check Grace Period
The app takes ~25s to run migrations on boot. Railway's
default health check starts probing at 5s and kills the
container after 3 failures.
¶Fix
Set in railway.toml:
[deploy]
healthcheckPath = "/health"
healthcheckTimeout = 60

The /health route must return 200 only AFTER migrations
complete — see app/Http/Controllers/HealthController.php.
¶Gotcha
Do not put the health check behind auth middleware. Railway
probes unauthenticated.

Three months later, when you deploy a different service to Railway and hit the same boot-time kill, the agent surfaces this skill immediately. No rediscovery. The forty minutes you spent the first time pays off every time after.

Two scopes

A skill can be saved in one of two places:

User scope (~/.elyra/agent/skills/) — available in every project you work on. Good for general techniques: "how I like to structure Pest tests," "the way to debug a hanging async stream."

Project scope (.elyra/skills/) — committed to git, shared with your team. Good for project-specific knowledge: deployment quirks, internal API conventions, that one service's authentication dance.

Project scope is the interesting one. When the agent saves a skill into the project, it's not just teaching your future sessions — it's teaching your whole team's sessions. A junior developer who clones the repo gets an agent that already knows the project's hard-won lessons. The knowledge compounds across the team, versioned alongside the code.

Approval by default

The obvious risk with an agent that writes files on its own is noise. If it saved a skill after every task, you'd drown in low-value markdown files within a week.

Two things prevent that.

First, the system prompt tells the agent to save skills only for genuinely non-obvious, recurring solutions — never for routine edits or one-off work. The bar is high on purpose.

Second, approval is on by default. The agent proposes; you decide. Every skill passes through your judgment before it's written. If the agent's instinct about "non-obvious" doesn't match yours, you discard it and move on.

Full autonomy, when you want it

For power users who trust the agent's judgment and want the full compounding effect, there's a toggle:

/settings → Auto-save skills → true

With that on, the agent saves skills without asking. It works silently in the background, building up your playbook as you go. This is the Hermes-style experience — set it and forget it, and come back in a month to an agent that knows things it didn't before.

The skill becomes active in the next session. There's a clean reason for that: skills load at session start, so a freshly written skill is ready exactly when you'd want it — the next time you sit down to work, not awkwardly mid-conversation.

Why this is in core

We could have shipped this as an optional extension. We didn't, deliberately.

Elyra's other "the agent gets smarter" features — codebase memory, smart routing, autonomous /goal execution — all live in core. They're horizontal capabilities that apply to every user regardless of their stack. Self-writing skills belongs in exactly that category. Hiding a fundamental learning capability behind an optional install would be the wrong call. An agent that learns over time shouldn't be a plugin. It should be what the agent is.

The bigger picture

Most AI coding agents are stateless in the way that matters. Each session is a fresh start. They're brilliant and forgetful in equal measure.

The fix isn't a bigger context window or a better model. It's giving the agent a way to write down what it learns in a durable, reusable, portable form — and then read it back later. Skills are markdown files. They live in your repo or your home directory. You can read them, edit them, delete them, commit them. No magic, no lock-in, just an agent that gets a little less forgetful every time it solves something hard.

Get it

npm install -g @elyracode/coding-agent@0.9.0

By default, the agent will start proposing skills when it solves something worth remembering. If you want the full autonomous experience, flip Auto-save skills on in /settings.

Full changelog: v0.9.0