Skill leaves

Axom starts as a generalist. A skill leaf makes it a specialist in the work you actually do, grown from its own mistakes while you do that work.

Say you use Axom as your sysadmin. The chassis isn't a sysadmin, so at first it slips: a log it misread, a service it didn't filter by, a restart it said it ran. Each slip is caught, fixed, and kept. When enough fixes pile up, they're pressed into a SysAdmin leaf. Axom stops making those mistakes, and the leaf is yours.

Make one

Create a leaf the way you'd create a project, then turn it on while you do that work:

/skill new sysadmin
/skill on sysadmin

/skill off turns it off. /skill on its own lists your leaves, which one is on in this chat, and how far each pile is toward a press:

● SysAdmin · 212 of 750 rows toward a press
○ Accounting · 48 of 750 rows toward a press

In the browser app, the leaf that's on shows in the chat header. Click it to switch or turn it off. Many people name a chat after the role: a "SysAdmin" chat, a "Head Dev" chat.

How a mistake becomes training

1. Caught. After every turn and every job, Axom checks what it did against the record, with no model call: a command that never ran, a file it said it saved but nothing wrote, a report two sections short of what you asked for, you asking again because the answer was wrong. Every signal names its evidence.

2. Shown, quietly. Axom's read appears beside the good and bad buttons after the turn ends, never during it:

   Axom's read: probably wrong. Said it restarted nginx; it never ran. · Agree · Actually fine

   One click agrees. Overruling asks for an optional one-line why, the most useful label there is. Your clicks are also how the checks themselves are scored.

3. Replayed. While your machine is idle, a teacher replays the failed turn (or the whole failed job) from its exact recorded prompt, knowing what went wrong. It runs on a copy of your workspace, and anything that would change your system runs dry. It stops the moment you send a message.

4. Verified. A fix is kept only if it passes the same check that caught the mistake, with nothing new going wrong. If no attempt passes, the mistake is set aside and never trained on.

5. Filed. The failed turn and its fix are kept together as one training row, in the right pile:

   • how Axom operates (tool calls, invented paths, claims without a record, ignoring the size of the ask) goes to the Operations pile, which improves Axom's own ops leaf for every field;
   • everything else that goes wrong while a skill leaf is on goes to that leaf's pile.

When a leaf is ready

At 750 verified fixes, Axom tells you the leaf is ready, in the "while you were away" line. Press it, and it snaps onto the chassis alongside the ops leaf. Collecting carries on past 750, so the next press is better still.

When Axom asks

Axom never makes a leaf on its own. If it keeps stumbling in a field you haven't named, those fixes are still verified and kept in an unfiled pile. Once a field has earned it (25 fixes, from 3 sessions, over at least 2 days), Axom asks once, at most once a week:

Axom keeps getting sysadmin work wrong: 31 fixes saved from 5 sessions. Make a sysadmin leaf from them?

Answer
/skill make [name]	Make the leaf, starting with those fixes
/skill notnow	Ask again when the pile has doubled
/skill never	Keep the fixes, never ask about this field again

Yours to keep, give, or sell

A leaf you grew is a file you own: the skill, without your data in it. Keep it private, give it to a friend or your team, sell it on the Leaf Store, or open-source it so everyone doing the same work starts where you finished.

Private by default

Checking, replaying, and filing all happen on your machine, under ~/.axom/data/. Nothing leaves unless you choose to send it, and you see exactly what goes before it does.

Where
data/collection/verdicts.jsonl	Axom's read of every turn and job, with your agree or overrule
data/learn/queue/	Mistakes waiting to be replayed
data/learn/rows/	Verified failed/fixed pairs, one file per pile

Settings

These are flags on axom serve:

Flag
--learn-idle <time>	How long the machine must be idle before replays start, for example 5m
--learn-teacher <who>	Who rewrites a failed turn. local (Axom with hindsight) keeps everything on your machine