The AI Agent That Rewrites Its Own Playbook
Most AI Agents Forget Everything
Spend an hour with an AI assistant correcting its output — its tone, its formatting, the specific way your team handles edge cases — and the next session starts from zero. Every preference, every correction, every hard-won piece of institutional knowledge: gone.
This isn't a memory problem. Memory systems handle facts: who you are, what project you're on, what you said last Tuesday. What they don't capture is procedural knowledge — how your agent should approach a class of problems, what techniques work, what patterns to follow. That kind of knowledge lives in your team's heads and in documentation that nobody reads.
OIDO has a different model. After every conversation, the agent reviews what happened and updates its own skill library — permanently, automatically, without anyone asking it to.
What Skills Actually Are
A skill in OIDO is a structured knowledge package: a SKILL.md file with a YAML manifest and a body of instructions that the agent loads before tackling related work. Think of it as a domain-specific playbook — "here is how to handle Django migrations," "here is our API design standard," "here is what to check before touching the payment flow."
---
name: django-migrations
description: "Safe migration patterns for our Django monolith."
allowedTools: [read_file, shell, edit]
---
# Django Migration Guidelines
Always run migrations in a transaction. Check for backwards-incompatible
schema changes before deploying. Run `python manage.py migrate --check`
in CI before any merge to main.
Skills can be bundled with the binary, installed from a registry, created by a project, or generated by the agent itself. That last category is where things get interesting.
The Self-Improvement Loop
After every conversation turn, OIDO spawns a background reviewer. This is a second, silent LLM call that reads the completed conversation and asks one question: what should the agent remember about how to do this kind of work?
User turn → Tool calls → Response
│
Background reviewer spawns
│
┌───────────────┴───────────────┐
▼ ▼
Memory update Skill update
(facts about user) (how to do this work)
│ │
MEMORY.md ~/.config/oido/skills/
The reviewer doesn't just log notes. It takes concrete action — creating new skills, patching existing ones, or adding reference files. The next time the agent encounters similar work, the updated skill is already loaded.
When a skill write succeeds, you see a one-liner summary:
💾 Self-improvement review: Skill "go-expert" updated.
Nothing else. The review is silent by design — it runs in the background, never blocks your response, and only surfaces when it actually does something.
When Reviews Fire
The reviewer triggers after every conversation that has at least four non-system messages. A one-liner exchange doesn't warrant a review. A real working session does.
The reviewer looks for specific signals before acting:
| Signal | Action |
|---|---|
| You corrected the agent's style or format | Patch the relevant skill |
| You said "stop doing X" | Embed that preference permanently |
| A non-obvious technique solved the problem | Add it to an existing skill or create a new one |
| The agent was wrong about something | Fix the skill that caused it |
The preference order matters: the reviewer patches the skill that was loaded in the current session first, then looks for an existing umbrella skill it can extend, then creates something new only if nothing fits.
Shared Skills Across Your Organization
For teams using OIDO Studio's multi-tenant deployment, self-improvement doesn't stop at the individual level. Skills can be written to an organization-level store — shared across every agent and every team member.
selfimprove.SpawnOrgAndWait(client, repo, orgID, messages, ReviewSkills)
When your team's agent discovers a better way to handle a database migration, that knowledge propagates to every engineer on the platform. Institutional knowledge stops living in someone's head and starts living in the skill library.
This is the compounding effect most teams never unlock: the longer you use the platform, the smarter your agents get at the work specific to your codebase, your standards, your way of doing things.
What the Agent Never Writes
The self-improvement system has explicit guardrails. The reviewer will never capture:
- Environment failures — a missing binary or expired credential isn't a skill, it's a config problem
- Negative claims — "tool X is broken" hardens into a refusal; the reviewer skips these entirely
- One-off narratives — single-use task context doesn't belong in a skill that will load every session
The distinction matters because skills affect every future conversation. A skill that says "never use the file-write tool" would break every coding session. The reviewer is instructed to be conservative: only capture recurring patterns with clear future value.
The Lifecycle
Skills don't accumulate indefinitely. OIDO tracks usage and manages a lifecycle:
active ──(unused >30d)──► stale ──(unused >90d)──► archived
A background curator runs after extended idle periods and handles the housekeeping: transitioning stale skills, consolidating overlapping ones, flagging conflicts. Bundled and hub-installed skills are protected — the curator only touches agent-created content.
Nothing is ever auto-deleted. Archived skills are recoverable. The goal is a skill library that stays lean and relevant, not one that grows without bound.
Practical Impact
The self-improvement loop changes the economics of deploying AI agents for real work. The common complaint — "we spent weeks tuning this agent and it still doesn't know our standards" — inverts. Every session where the agent does real work is a training session. Every correction you make is a permanent improvement.
For engineering teams, this means:
- Code review standards accumulate over weeks of use, not a one-time setup session
- Domain-specific patterns get captured as they're discovered, not as documentation tasks
- Corrections compound — fix something once, and it stays fixed
Try It
OIDO is free to start. Deploy an agent, work with it for a few sessions, and watch the skill library grow. The first time you see a self-improvement summary appear after a conversation, you'll understand why this changes the bar for what "getting better at your job" means for an AI agent.