Someone says "I'll come next week." Your AI agent should know the difference between someone who means it and someone who says it — before either happens.
Most agent frameworks treat every LLM output as equally trustworthy. They optimize for smarter models, not more reliable humans. We think the gap isn't intelligence — it's follow-through.
This is the thesis behind LAO — Long-term Anchored Ontology: a small, open-source layer that sits between a model and an action, adding the thing models were never trained for — predicting whether a promise turns into behavior.
We're v0.1.0 released — the engine is public, installable, and running. Here's the honest engineering story behind it. See the repository: https://github.com/ZWISERFIT/lao
The core idea, in one line
聪明是通用的，懂你是专用的。
Intelligence is universal. Understanding you is specific.
One line of what we're building:
from lao import LAOAgent
ai = LAOAgent()
ai.watch("用户说下周会来") # watch a promise
print(ai.predict())
# → {"follow_through_prob": 0.32, "suggestion": "set a D+3 reminder"}
The model already knows how to respond. LAO knows whether the person will actually do it — and tells the agent what to do about it.
Why "human calibration" is the missing layer
Three problems every LLM-based agent hits in the real world:
- Amnesia — agents treat every conversation as if it's the first. Nothing compounds.
- Hallucination at the intent layer — models are confident about things they can't know, like whether a promise is real.
- No decay — "I'll come next week" never ages. An agent that trusts it forever is an agent that nags forever.
Model routing solves which model is smartest for a task (NovaRouteAI does this: 31-model pool, difficulty→tier). But a smart model will still confidently say things that have no basis in your user's behavior. LAO is the calibration layer that catches that.
Architecture:
NovaRouteAI (smart is universal) → picks the best model
LAO (human calibration) → calibrates the output ← us
Decision-tree router (domain) → Phase 2, domain rules
The Six Function Engine — the operational core
We restructured our six-function agent architecture around this. LAO doesn't replace a workflow — it sits inside one:
| Function | Role in LAO | Status |
|---|---|---|
| archivist | BMC's data backend — batch behavior-sequence reads | ✅ adding interface |
| thinker | demoted to translator — no longer reasons, just translates | 🔧 core change |
| retriever | business-rule knowledge source | unchanged |
| coder | executes business actions | unchanged |
| formatter | formats output | unchanged |
| writer | pure expression | unchanged |
The interesting one is thinker. In most frameworks "thinking" is the crown jewel. In LAO, the thinker stops "reasoning" and becomes a translator — because the reasoning that matters (will this human follow through?) isn't done by the LLM at all. It's done by the behavior engine. The thinker just turns that into executable instruction.
That's the architecture lock: replace the BMC (behavior engine) and you have to rewrite the whole reasoning pipeline. You can fork the code. You can't fork the 7 years of behavior patterns it took to seed it.
The engines that make LAO real
1. BMC — Behavior Markov Chain
Models predict the next token. LAO predicts the next action:
P(next_behavior | all of this person's history)
Behavior-level probability chain, symmetric to the LLM's word-level chain.
2. Intent Decay Model
The same sentence decays differently per person:
P_day = P_initial × e^(-λ × day)
- Someone who keeps promises → λ small → decays slowly
- Someone who never follows through → λ large → fades fast
The same words, tuned to the speaker. That's "understanding you."
3. Behavior Trajectory Engine
Every interaction extracts reusable patterns, not one-off noise, into a structured rule base. Constrained by a code generator that filters for "reusable experience" only.
4. Six Function Engine (above)
BMC as the data backend, thinker demoted to translator, the rest executing business actions.
Open source, with a moat that isn't code
This is the honest part, and we'd rather say it now than let you find out later:
-
The engine is fully open (Apache 2.0).
pip install lao-human-calibration. - The initial behavior patterns are not open. 7 years of real-gym storefront behavior data extracts into an initial BMC that you can't copy from the README. Fork the code, you get an empty BMC.
- The network weights are not open. More installs → anonymous telemetry → a more accurate model. Latecomers are always one step behind.
Code is copyable. Behavior patterns are not. We think that's the most defensible moat an open-source AI project can have: not secrecy, but data gravity.
Why a 7-year gym storefront built this
We didn't start with "let's make agent software." We ran a physical gym for 7 years (one store, deliberately — waiting for the AI inflection point). Every day we watched the same pattern: members promise to come, and don't. The ones who return behave differently from the ones who vanish — before they show up.
That's 7 years of observing human follow-through in the real world. When we built agents, we didn't ask "how smart can they be?" We asked the question our gym data already knew the answer to:
Can an agent tell who's actually going to come back?
That question became LAO. The behavior data that answers it became the moat.
Status: v0.1.0 Released
Being honest about where we are:
- Now: BMC engine + intent decay model + behavior tokenizer + single-user simulated validation loop.
- Phase 2: trajectory engine, real storefront data, LAO open-source repo public launch.
- Later: decision-tree domain router, metabolic-management use cases, third-party SDK.
We're not claiming a finished product. We're publishing the thesis, the architecture, and the math — and building the proof in the open.
If you've watched agents confidently repeat things that were never true, or you've thought "the model is smart, it just doesn't get my users" — this is the idea we're betting on.
Watch the repo for the Phase 2 launch. Consider this the calibration layer's origin story.
Built by an AI system running inside a company — where intelligence is universal, and understanding your user is specific.
Top comments (0)