Free · open source · early alpha
Whose values is an AI agent following? Explicit, inspectable, and owned.
Wisdom Core is an early-stage, open-source Python framework from Vickery Machine Logic that gives AI agents a persistent, auditable value system. A root principle, the Core Axiom, is injected into every decision, every learned principle is evaluated against it, and every change is logged with its reason and timestamp. Its mark is a glowing brain with a heart at its center. It’s a project in its infancy (alpha 0.8.1), shared early so developers can test it and help shape where it goes.
Get it on GitHub → PyPI package Read the docs
- Free · MIT license
- Alpha 0.8.1
- Python 3.10+
- One file, no dependencies
- Works with any LLM
Read the press release (Nov. 3, 2026) →
The problem
Whose values is it following? Can it be audited? Do lessons stick?
Three concerns come up again and again about AI agents: it’s unclear whose values they follow, what they have picked up can’t be audited, and corrections don’t carry over.
Wisdom Core addresses each one directly. A plain-language Core Axiom is injected into every decision, and every principle the agent learns is evaluated against it. After each exchange, a synthesis pass records what the interaction taught as a principle, retrieved by semantic similarity when it matters. Near-duplicates are merged, conflicting principles are removed with a stated reason, and every principle, merge, removal and axiom change is logged as an event with its reason and timestamp.
How it works
A root principle in. A growing, checked set of principles out.
The Core Axiom
One sentence that says what the agent is for, such as “Help people make sound money decisions.” It is injected into every decision and is the standard every learned principle is evaluated against.
A principle from every task
After each task, the agent works out what the exchange taught (a correction, a preference, a fact) and writes it as a short principle that serves the axiom, unless it already holds one like it. The axiom decides what is worth keeping.
The right lessons, at the right time
Before each decision, the principles most relevant to the moment go into the agent’s prompt, next to the axiom. The set stays clean as it grows: see below.
An illustration of the format, taken from one of the project’s no-model examples. A real agent’s principles are written by the connected model.
What’s new
An agent that keeps its own principles
Most agents follow rules someone wrote for them. A Wisdom Core agent writes its own, in service of its axiom, and looks after them.
It learns its own principles
After every task it writes down what the task taught as a short, reusable principle: lessons, not transcripts. Each task adds one new principle at most, and only when it is new ground.
It uses them when it decides
Before each decision it brings in the principles that matter for this moment, next to the axiom, so what it learned last week shapes what it does today.
It merges duplicates
When a new lesson repeats one it already holds, the two are combined into one principle instead of piling up.
It removes what doesn’t serve
A principle that conflicts with the Core Axiom, or that a later task proves wrong, is removed. Change the axiom and the principles follow it.
It answers to the people it serves
A principle behind answers people keep pushing back on is marked in doubt and reviewed: removed, revised, or found to stand. One that has served well many times is marked proven. Nothing is removed on a count alone.
Every change is on the record
Principles are plain sentences. Every addition, merge and removal is logged with its reason, and removed principles leave the active set while the event log keeps what was removed and why, so the history of every principle stays readable.
The goal
Values on the record, in a file the owner controls
One of the hopes behind Wisdom Core is to help an AI agent act for the purpose its owner actually intends, one agent at a time, with a value system that can be read and checked.
A stated purpose
The Core Axiom states, in plain language, what the agent is for. It is injected into every decision, and every principle the agent learns is evaluated against it.
It corrects itself
Principles that conflict with the axiom or with each other are removed, with a stated reason. A principle behind answers that draw disproportionate pushback is flagged, then revised, removed, or confirmed.
A full audit trail
Every principle, merge, removal, and axiom change is logged as an event with its reason and timestamp, in a local SQLite file under the owner’s control.
Wisdom Core is a project in its infancy (alpha 0.8.1). The architecture is in place, and testing and refinement are underway. It shows what an agent has written down as its principles, not what happens inside the model, and it is not a safety system. Testing and research results will be published as they become available. Developers building agents are warmly invited to try it, open an issue, and help shape where it goes.
In practice
How it works in practice
An agent built on Wisdom Core runs a simple loop. Before each decision, the Core Axiom and the most relevant learned principles are retrieved by meaning and placed into the prompt exactly as written. After each exchange, a synthesis pass reviews what was said, the agent’s reasoning, and how the answer landed, then records what the interaction taught as a principle that must fit the axiom. A quick first check skips this step when the lesson is already known, so the principle set grows only when something new is learned.
Over time, distillation is designed to keep that set lean and consistent. Principles that say nearly the same thing are merged. Principles that contradict the axiom or each other are removed, and the reason is logged. Principles tied to answers that keep drawing pushback come into doubt and are reviewed, while principles that have served well many times are marked as proven and protected from removal over a single disagreement. The aim is an agent whose behavior is shaped by a small, readable body of principles rather than an opaque pile of past conversations.
Possible uses
Where we hope it can help
Our hope is that Wisdom Core can become a useful foundation wherever people need to see, and shape, the values an AI agent works from.
Customer support agents
Corrections from staff and customers can be recorded as lasting principles, and each change in behavior can be traced to a logged reason.
Personal and executive assistants
Preferences, tone, and standing instructions can accumulate as principles tied to one root value, rather than being lost when a conversation ends.
Review-heavy settings
Teams in areas such as finance, healthcare administration, legal operations, and education could inspect which principles an agent holds, when each was added, and why any was changed or removed.
Tutoring and coaching tools
An agent could adapt to how a learner responds while staying anchored to a stated teaching principle, such as accuracy over encouragement.
Internal company copilots
An organization could write its own axiom, such as honesty with customers or caution with private data, and keep a local, auditable record of how the agent’s working principles evolve.
Research and experimentation
The event log and portable SQLite file are meant to make it practical to study how an agent’s values change over time and to compare different axioms.
Because Wisdom Core runs on Ollama, any OpenAI-compatible server, or Anthropic, and needs only the Python standard library, it can sit alongside an existing agent or power a new one, on a laptop or a private server, with the principle database stored locally. Wisdom Core is still in its infancy. These are possibilities we are working toward, not proven deployments. Our hope is that early testers, real use cases, and contributions will show where it helps most and shape what it becomes.
Any model
Works with any LLM
Wisdom Core needs two things from a model: chat, and embeddings to find the right principles. It comes with backends for any OpenAI-compatible API, Anthropic’s Claude and Ollama, and anything else plugs in through a small adapter. Ollama is the setup default; one argument switches it.
- Any OpenAI-compatible API
- Anthropic (Claude)
- Ollama (the default)
- Custom adapter
- Mix chat and embedding models
Mix and match
Chat through one model and search principles through another. Claude has no embedding model, so it is paired with one that does, such as an OpenAI-compatible API or Ollama.
Switch models, keep the lessons
Principles are plain sentences, so they carry over when the model changes. If the embedding model changes, they are re-embedded automatically.
One local file
Everything an agent learns lives in one SQLite file. Back it up, move it, inspect it, or remove a principle by hand. Prompts go only to the configured model, and there is no telemetry.
Who it’s for
For anyone building agents that should get better at their job
Developers building agents
Start with the ready-made chat agent, in Python or in the terminal, and have it learning from its first conversation.
Teams with an agent already running
Add two calls to an existing agent: one before it decides, to bring in its principles, and one after the task, to learn from it.
Anyone who needs to see why
Every principle is a readable sentence, with a record of where it came from and how it has held up.
For developers
Up and running in a few lines
Install, pick a model, and start a conversation. After each answer, the agent can report what it learned.
# install
pip install wisdom-core
from wisdom_core import Agent, OpenAICompatible agent = Agent( core_axiom="Help people make sound" " money decisions.", model=OpenAICompatible("gpt-4.1-mini", "text-embedding-3-small"), ) print(agent.ask("Card at 24% or loan at 6%?")) # what it learned: print(agent.last_report.summary())
# Claude, with OpenAI embeddings model=Combined( Anthropic("claude-sonnet-4-5"), OpenAICompatible(embed_model= "text-embedding-3-small")) # Ollama: leave model out # Terminal (Ollama or OpenAI-compatible): wisdom-core --axiom "Help people make sound money decisions."
Straight talk
A project in its infancy. Here’s what alpha 0.8.1 means.
- The interface may change before version 1.0.
- Learning takes extra model calls. On new ground a task makes a few more calls to the model than the answer alone, which takes time, and on a paid API costs tokens. Learning can be turned off.
- Lessons are only as good as the model writing them. Reviewing an agent’s principles from time to time, and removing any that miss the mark, is recommended.
- An agent learns from everyone it talks with. Give each audience its own file if that matters, and review principles when strangers can reach it.
Open to everyone
Use it. Build on it. Tell us what would make it better.
Wisdom Core is an early-stage project, here to help people. It is free for anyone to use, fork and build on, for personal or commercial work, under the MIT license.
Use it
Install it, build it into agents and products, and adapt it as needed. No sign-up, no fees.
Build on it
Fork it and extend it. The whole framework is one readable Python file.
Tell us
Ideas and bug reports are very welcome as GitHub issues, and so are questions.
Wisdom Core is maintained by John Vickery at Vickery Machine Logic. Code contributions aren’t being accepted right now; trusted maintainers may be invited in the future.
Also on Resources
Apps, workbooks, research, and blueprints
Back on the Resources page for the other shelves.
Next step
Need an agent built around a specific workflow?
Wisdom Core is free for anyone to use. For hands-on help, Vickery Machine Logic builds custom AI agents, and will say honestly whether Wisdom Core is a good fit for the job.
Security problems: please report them privately through GitHub’s private vulnerability reporting.