Skills & learning

An agent that solves the same problem twice has learned nothing. Nouride agents keep notes — and by default you approve every one before it counts.

The notes are called skills. A skill is a short document: how to do one kind of job, the order the steps go in, and the things that go wrong. Before an agent starts a job it reads the skills that look relevant, so a lesson written once is available to every agent, on every platform, from then on.

One pool, per-agent switches

There is one skill pool at .nouride/agents/skills/, and every agent is offered all of it. An agent’s exceptions live in skills.toml beside its pack:

[skills]
document-authoring = false     # off for this agent only

Default-on rather than an opt-in list, because a list written today cannot name a skill that arrives next month — every later skill would show up switched off with nothing to say why.

Three ways to flip that switch, all writing the same file: the Skills Workshop, the agent’s own Skills tab, and the CLI.

nouride skills                  # what the default agent is offered, and when each was last read
nouride skills nouva -v         # for one agent, verbose
nouride skills --all            # the whole pool: who has each, and what software is missing
nouride skills off document-authoring nouva
nouride skills on  document-authoring nouva

There are three scopes a skill can come from, and the Workshop labels each row:

Built in	ships inside the executable. Cannot be deleted; override it by putting a pool skill of the same name over it
Shared	the pool — what you and the agents write
Project	a SKILL.md inside a directory you listed as a skill_root for that agent

[skills] off in the daemon config is the other axis: names nobody loads, whatever their own skills.toml says. That is a removal rather than a preference, and it exists mainly for the built-ins.

Where skills come from

Three places, and you are in the loop for all of them.

You write one. Ask the agent to save a procedure and it writes what you dictate.

The agent asks to write one. Mid-conversation it can say “this is worth keeping” and hand you a draft.

The agent notices on its own. That is the rest of this page.

What makes it look up

Nothing runs on an ordinary turn — that would be slow and expensive. The pass costs one short model call, and only after a turn where something actually happened:

• You asked for it. “Remember how we did this.”
• Something broke and then worked. min_tool_failures failures (3 by default) in one turn, then a success. The failures are what make it worth writing down.
• The conversation got long in effort. reflect_after model round-trips (8 by default). A turn counts for one, plus one for every round of tool use, plus one more if your reply arrived within three minutes of the agent’s last word — which is how “you were steering” gets counted without reading a word of what you said.
• It got something genuinely new working.

These are all about the shape of what happened, not its meaning. Nothing has been judged yet.

The daemon deliberately does not try to judge it either. An earlier version matched phrases like “still broken”, which fails silently for anyone whose wording nobody anticipated. Counting is dumb, free and language-agnostic; the judgement belongs to the model.

What it decides

The agent reads the conversation back and asks one question: should the skill library change because of this? Four possible answers, first one that fits:

Update	A skill already covers this. Add the missing step or the pitfall to it.
Attach	A skill covers it, but what was learned is bulky — a long command, a config that worked, an error and its cause. Put it in a file beside the skill instead of swelling the skill.
Create	Nothing covers this. Write a new skill — and say which existing one came closest, and why it should not just absorb this.
Skip	There is genuinely nothing here.

Skip is real, and it should be rare after a long session. If you spent an afternoon getting a camera connected and it now works, the camera is a one-off but the procedure is not.

How much runs without you

[rsi] mode, and on the Skills page. The middle one is the default.

require_approval — propose, and wait for me. A draft is a proposal, not a change. Pending drafts pin to the top of the Skills page. Each shows what the agent wants to add, why, and — for an update — a line-by-line diff against the file on disk, because an improvement is usually one added pitfall in a sixty-line body and asking somebody to spot it by eye is asking them to approve without reading.

off — nothing is examined. Drafts already waiting stay exactly where they are, still yours to decide.

always_allow — let it keep what it learns. The agent approves its own drafts as it writes them and tells you afterwards in the chat it was working in. Worth knowing before you pick it: a skill is read by every agent here on every matching turn, so a bad one is wrong repeatedly and quietly rather than once and visibly. What you have afterwards is the audit log — the row records the daemon as the approver — and nouride skills off <skill> <agent> to take one back out.

Anything unrecognised in that setting is read as require_approval, never as always_allow: a bad value should cost an approval, not grant autonomy.

Working through the queue

nouride skills drafts            # what is waiting on you
nouride skills draft <id>        # one draft in full, with the turn it came from
nouride skills approve <id>      # into the pool
nouride skills deny <id>         # discarded

Or /drafts in a chat, or the Skills Workshop, whose three tabs are one workflow:

Tab	Shows
All (default)	the queue first, then the pool — what is waiting above what is settled
Live	the pool alone: what the agents are actually carrying
Pending	the queue alone, plus what was recently decided

Each draft row opens into the whole SKILL.md, editable in place, plus the scrubbed transcript of the turn it came from. Both are on the row rather than behind a navigation, because the decision is “do I want this in every agent’s prompt” and the evidence for it is the turn.

A draft is not an approval. It blocks nothing and it never expires. That is why it lives in the Workshop and not in the approvals queue — putting them together would give one of them the wrong lifecycle.

Two things an agent may never do

Whichever mode you pick:

• Change a skill you wrote. If your name is on it, the loop leaves it alone however well it fits. Suggestions about your skills arrive as a draft, never as an edit.
• Delete a skill. Only a person removes one.

The guardrails

It will not flood you. max_pending (20) is a ceiling on waiting drafts. Once reached, the loop stops proposing until you clear some. Near-duplicate drafts supersede each other rather than piling up.

Credentials are removed. Tokens, keys and passwords are stripped out of a conversation before the agent reads it back, and again before anything is written to disk.

Skills are written in English, whatever language you were speaking. One library, one language, so any agent can read any skill.

It waits between looks. cooldown_ms, near zero by default — what should throttle reflection is work done, and the trigger already counts that. Asking for a skill in words ignores the cooldown entirely; a person asking is not noise.

What a good skill looks like

Named for the class of job, not today’s instance. deployment-docker, not fix-the-build-on-tuesday. If the name only makes sense today, it is the wrong name — and the agent is told to reach for updating an existing skill before inventing a new one, because two skills covering one subject is worse than either alone: the agent loads one, the lesson is in the other, and neither gets trusted.

Each skill declares what it needs — programs that must be installed, tools the agent must be allowed to use. nouride doctor reports both gaps, per host and per agent, because the alternative is a skill that loads fine and dies on step four with dot: command not found, halfway through a task, with an approval already spent.

Skills cost something

Every skill costs a line of every agent’s system prompt on every turn, whether or not it is ever read — measured at ~3.4 KB for eighteen of them on a live box. nouride doctor lists skills nobody has opened in the audit history for exactly that reason. It reports them as fine rather than as a fault: an unread skill is a bill worth knowing about, not a bug.