Learning Loop (agents that learn from finished work)
The Learning Loop lets your agents get better with use. In the background, Omniscio looks back over finished work, turns a hard task into a skill and a fact about you into a memory, checks every save, asks you before anything that spreads or touches your own skills, and keeps everything on one timeline where you can undo it. It is in development, so it is off by default.
On this page
What it is
Agents start every session from scratch. Without help, the fifth time an agent works out how your project's release script behaves, it works it out the same way it did the first four times. The Learning Loop is how Omniscio remembers for them.
It is a reviewer that belongs to the app, not to any one session. When a session reaches a natural break, the reviewer reads the newest stretch of that conversation with a separate, inexpensive AI model and decides whether anything in it is worth keeping. It never adds a turn to your session, never uses the session's own model, and your session never waits for it.
It keeps two kinds of things, and keeps them apart on purpose:
- Skills — know-how: how a hard task was done, a procedure that worked, a trap to avoid next time. A skill is the same kind of file you already use in Skills, so Claude Code sessions load it when it is relevant.
- Memories — facts about you: what you said or showed about yourself, the people you work with, or your project. They go into Global Memory, next to the memories your agents save themselves.
A procedure never becomes a memory, and a fact about you never becomes a skill. Reading a session does not count as learning from you either: a memory is kept only when a line you typed backs it, so text an agent read on a web page or in a tool's output can never be saved as something you said.
It reviews sessions on every engine. What it learns reaches your agents through the roads skills and memories already travel: learned project skills load into Claude Code sessions for that project, and memories reach every session that reads Global Memory.
Where to find it
- Turning it on. While it is in development, the switch lives in Settings → Lab → Learning Loop. Once it is on, the Learning settings section and the Learning timeline appear.
- On your phone. The Learning timeline is on the phone app too: see The timeline on your phone.
- Settings → Learning. The master switch, the daily spending limit, which models review and draft, what counts as a big task, how long a session must be quiet before it is reviewed, how many new skills a day are allowed, how much the chat says, and how long history is kept. Every setting is described in Learning Loop settings. When the switch is off, the section says so and explains that nothing is reviewed and nothing is spent.
- The Learning timeline. In the sidebar under Agent Tools → Learning, titled What your agents learned. It also opens on the phone app.
- Approval cards. Anything that needs your yes arrives as a card from Learning Loop in your approvals, alongside every other approval.
- Inside a session.
- A short line appears in the conversation when something is learned from it, such as Memory updated: prefers pnpm or Skill saved: release-checklist (this project).
- The session's ⋯ menu has Review what was learned now (default shortcut Alt+Shift+L, rebindable).
- Typing /refine on its own in the message box does the same thing, on any engine.
How it behaves
When a session is reviewed
A session is reviewed at natural break points, never after every reply:
- After a big task — once a session has taken 20 tool steps, or worked for 15 minutes, since its last review. Both thresholds are adjustable.
- When it goes quiet — after 30 minutes with nobody touching it (adjustable), so work you are still doing is never interrupted.
- When it ends.
- When you ask — with /refine, the ⋯ menu entry or the shortcut. Your request goes ahead of every waiting review and ignores the big-task and quiet thresholds.
Each stretch of work is reviewed once. A session picks up from where its last review stopped, so a long session is reviewed in pieces and no piece twice. A review reads only the new stretch, so a very long session does not cost extra memory to review. A stretch with fewer than four new messages waits until there is more to read, unless you asked. Only one review runs at a time across the whole app, and Omniscio checks for sessions that are ready every few minutes.
Which sessions. Only sessions you started yourself are reviewed. A session started by someone else — a text, an email or a message from outside — is never reviewed, so a stranger can never teach your agents anything. Clean Room sessions are never reviewed. Helper sessions an agent crew launches are not reviewed either.
Your scheduled jobs and recipes (optional). Sessions started by your own schedule or your own recipes are skipped unless you switch on Also learn from my scheduled and recipe sessions in Settings → Learning. It is off by default. When it is on:
- Only your own runs count. A recipe you started yourself or that a schedule started is included. A recipe started by an email, a message, a board, another agent or an automation is never reviewed.
- They teach skills only. Nobody was watching these runs, so nothing about you is saved as a memory, and every skill they suggest waits for your approval, even for its own project. The card says A scheduled run — nobody was watching it or A recipe run — nobody was watching it.
- They are reviewed after the run is over, never halfway through, and at most once a day for each scheduled job or recipe. A run that failed does not use up that day. Asking with /refine is not limited to once a day.
When you ask with /refine, the session tells you what happened in one line: the review started, the Learning Loop is off, the session is not one that is reviewed, a review is already running, you need an AI key, or today's budget is used up. When the review finishes you get a second line saying what it found, or Nothing new to review since the last review.
What a review keeps
A single review keeps at most three memories and suggests at most two skills.
- Memories must be facts about you, your people or your project, and each must point at a line you typed in that stretch. The default is to keep nothing, and that is the normal outcome.
- Skills are drafted by a stronger model (the strongest one your accounts can reach, unless you pick one), then read again by a separate safety check before they can be saved. A skill can be new, or an improvement to one that already exists.
Every save is checked
Before the reviewer reads anything, passwords, keys and tokens in the conversation are replaced with placeholders. Then every memory and every skill is checked again before it is kept, for:
- something that looks like a password or key,
- an access token,
- login details,
- planted instructions — text written to steer future agents.
A memory that fails is held: nothing is saved, and a card shows you the text with the sensitive parts already hidden. Approving saves exactly that hidden-parts copy; rejecting saves nothing. This check covers every memory save, including the ones your agents make themselves while they work, not only the Learning Loop's own.
What goes live, and what waits for you
| The change | What happens |
|---|---|
| A new skill for this project, or an improvement to one the Learning Loop wrote for this project | Saved at once, with a line in the session |
| A skill for all of your projects | Waits for your approval |
| A change to a skill you wrote yourself, or one whose author is unknown | Waits for your approval |
| A skill that shipped with Omniscio, came from the catalog or arrived with a plugin | Never changed |
| Anything the checks flagged | Waits for your approval |
| A skill change an agent or a script asks for through Omniscio's control server | Always waits for your approval |
A skill card shows what the skill says now beside what it would say after the change. For a new skill meant for all projects, you can choose Use in this project only before approving. If you edited the skill after the card was raised, approving changes nothing and tells you so; you are never asked to overwrite your own newer work.
Where learned skills are kept. A skill the Learning Loop writes for a project lives in a folder Omniscio keeps for that project, outside your repository, so nothing appears in your git history. Claude Code sessions for that project load it from their next start (this needs Claude Code 2.1.0 or later). A change to a skill that already lives in your project's own skills folder lands there, and a skill for all projects lands in your personal skills folder.
The Learning timeline
What your agents learned lists every save, every held item and every decision, newest first:
- A Waiting for you strip at the top holds anything that still needs your approval, each with a Review button that opens its card.
- Filters narrow the list by type (memory, skill or review), by status (live, waiting, held, undone and so on) and by project.
- Each learned skill also shows in the Skills panel with a Learned badge. Its History, Undo and Edit buttons open this timeline on that skill, with a Showing one skill row and a Show all button to see everything again. These buttons are on the computer only.
- Each entry can be opened to View the text before and after, Undo it, Restore it after an undo, or Open session to jump to where it was learned. A skill entry can also be Edited.
Nothing is ever hard-deleted:
- Undoing a memory archives it, and restoring brings it back.
- Undoing a skill change puts back the version it replaced. Undoing a brand-new skill removes it but keeps a copy, so restoring puts it back exactly. The last ten versions of each learned skill are kept.
- If something changed since the entry was recorded, undo and restore leave it alone and say It changed since, so nothing was touched.
Editing a learned skill makes it yours. After you save an edit from the timeline, the Learning Loop treats that skill as one you wrote, so any later change to it waits for your approval. The most recent entry of every skill that is still live is always kept, even when older history is cleared, so you can always view, undo or edit it. Editing is something only you can do from the app; no agent or script can do it on your behalf.
The timeline on your phone
The same timeline opens on the phone app. Tap an entry to open a full-screen page that shows what it said before and after, with these buttons:
- Undo or Restore, the same as on the computer.
- Refine, which asks for a review of the session the entry came from. It is limited to a few taps in a row, because every review spends your daily learning budget.
- Open session, which jumps to where it was learned.
Edit is not on the phone. Editing a skill rewrites what every future session of that project reads, so it stays on the computer; the phone page says Edit on your computer instead.
When memories pile up: combining
Each memory area (about you, your people, or one project) has a size limit, Memory size limit in Settings → Learning (30,000 characters by default). When an area grows past it, and Merge near-duplicate memories is on, a background run in the Learning Loop merges memories that say nearly the same thing into one shorter memory.
- Up to three rounds per run, stopping as soon as the area is back under its limit or nothing more can be merged. Nothing is merged while an area is under its limit.
- Every merge is a line on the timeline: Memories combined — 3 into 1. Undo brings back every original memory and archives the merged one; Restore redoes the merge. Nothing is deleted.
- A merge you undid is never redone. The memories you brought back are left alone.
- Every merged memory is checked for passwords, keys and planted instructions like any other save.
- It costs a little, counted under the one daily learning limit. If you have no AI key of your own, or today's limit is spent, you get one Couldn't combine line for that area per day and nothing is merged.
Letting the reviewer see tool activity
With Let the review see tool activity on (it only applies to Claude sessions), the reviewer also sees the tools a session ran and what came back, so it can learn from what actually happened, such as a command that failed and the one that fixed it.
- Each tool call is shown as a short line: the input cut at 600 characters, the result at 1,000, and secrets removed. The reviewer sees at most about 12,000 characters of these lines, and failed calls are kept first.
- Tool lines never count as evidence for a memory. A memory is still kept only when a line you typed backs it.
- If the tool record cannot be read, the review simply goes ahead without it.
Project skills in other coding tools
Codex, Gemini and Hermes sessions can use a project's own skills and the skills learned for it, not only Claude sessions. This needs all three of: the Learning Loop switch in Lab, Sync to other AI tools → skills in Settings, and Share project skills with other coding engines in Settings → Learning (on by default).
- Codex and Gemini get copies in the project's
.agents/skillsfolder, kept out of git so they never show up as changes. A folder you made yourself is never touched, and a copy you edited is kept. - Hermes reads the skill folders where they are, so nothing is copied.
- Your global skills folders are never touched.
- A project's own skills win over a learned skill with the same folder name, and at most 100 skills are shared per session.
Cost and limits
- One daily limit. All learning spend — reviewing, drafting and checking — counts against one daily spending limit (default $1). When it is reached, reviews pause until tomorrow and a card tells you once that day, with a button to raise the limit. Nothing is lost: work done while paused is reviewed the next day.
- Each review's cost shows under its session. The spend of reviewing, drafting and checking is recorded against the session that was reviewed, so the per-session spend breakdown in Stats shows what learning from that session cost.
- It uses your own AI key. Reviews run on pay-per-use models. Without a key of your own, nothing is reviewed and a card says so, at most once a week, with a button to Settings.
- Growth is bounded. New skills are capped per day (default five; zero stops new skills). History is kept for 90 days by default. A learned project skill nobody has used for 30 days is archived, with a copy kept so it can be restored from the timeline. An unused all-projects skill is never archived on its own; it gets one note on the timeline instead, and the choice is yours.
- Failures stay quiet. If a review fails, it is tried again later. After three failures on the same stretch of work it gives up on that stretch, records that on the timeline, and moves on. Your sessions never see an error from it.
Turning it off
Turning the Learning Loop off stops every review and all learning spend at once. Skills and memories it already saved stay exactly as they are, and so does the timeline.
It replaces Global Memory's session-end summarizer
Global Memory used to run its own summarizer at the end of each session. The Learning Loop does that job now, with the checks, approvals and undo described above. If you use Global Memory, the Learning Loop is turned on for you once, so your memories keep being saved without you doing anything; your summarizer's model choice and daily limit carry over with it. A one-time card tells you it was turned on and links to the Learning switch, where you can review it, set its daily limit or turn it off — and turning it off stays off.
Related
- Use Skills — browsing, installing and editing skills; learned skills sit beside them.
- Global memory — where learned memories are kept and how agents read them.
- CLI pending actions — how approval cards work, including the four Learning Loop kinds.
- Learning Loop settings — every setting, its range and its default.
Last verified 2026-10-28