Human-AI Learning System · First vertical proof: Trading Brain

A learning system
for humans and AI
to think better together

NOUS OS connects human intent, learning notes, verified memory, agent routing, outcome proof, and human authority —
with Trading Brain as the first vertical proof and production hardening in progress.

Launch Demo ↗ See the Flywheel → View on GitHub
Hermes / Aria = human intent layer Obsidian = knowledge sedimentation TrustMem = verified memory Synapse = event mesh trading-agent = first runtime proof
NOUS OS = a human-AI learning system: human intent + readable notes + verified memory + agent coordination + measured outcomes + human authority.
North Star V2
A verifiable learning loop
The system connects intent, operating notes, durable memory, event routing, runtime truth, and outcome proof into a repeatable learning loop.
Authority boundary
Human judgment stays final
NOUS OS can route, recall, score, and brief. It cannot bypass irreversible broker, risk, reconciliation, approval, or live-state boundaries.
NOUS OS human-AI learning architecture map showing Human, Hermes and Aria, Obsidian, TrustMem, Synapse, domain runtime, outcome proof, and human authority boundaries
Architecture map: Human -> Hermes / Aria -> Obsidian + TrustMem + Synapse -> domain runtime -> outcome proof. Generated with Fireworks Tech Graph · review-only
Live Demo

See the cognitive loop, not just the architecture

The demo shows the full loop in one continuous flow: Aria planning, Synapse dispatch, TrustMem recall, human override, and measurable improvement from one run to the next.

nousos.ai / live demo / benchmark reveal
Aria Synapse TrustMem Open Full Demo

What this proves

NOUS OS is not just a workflow. The demo measures whether the second run is actually better after memory recall and human correction — across quality, correction absorption, efficiency, and repeatability.

CLS
Cognitive Loop Score
Q / C / E / R
Public Benchmark Axes
Q measures whether outcome quality improves from baseline to the memory-backed second run.
C measures whether one human override is actually absorbed by the system rather than lost.
E measures reuse of memory and shared context instead of restarting from zero.
R measures whether the second run is stronger in a way that can be repeated and explained.
Proof strip
100%
Hit@5 Retrieval
290K+
msg/sec throughput
183
agents · 67ms startup
11 days
production deployment
Why NOUS OS

Not another agent framework.
A cognitive operating system.

NOUS OS is called an operating system because it does more than run agents. It integrates consciousness, trusted memory, coordination, and human correction into one compounding cognitive runtime.

why the name matters
Not just automation
Higher intellect, not just intelligence
"Nous" refers to higher intellect — the capacity to perceive, judge, and organize meaning. That makes it a better name for this system than assistant, copilot, or workflow engine. NOUS OS is designed to enhance human cognition, not replace it.
Not just a product
A runtime, not a feature bundle
An operating system does not provide one feature. It provides the runtime that coordinates all features. Aria, TrustMem, and Synapse are not isolated modules — together they form the cognitive runtime on which agents, workflows, and decisions operate.
Not just more memory
Interaction becomes future intelligence
Most systems can execute tasks. Few can turn interaction into future intelligence. NOUS OS compounds because memory shapes judgment, judgment produces outcomes, human correction updates trust, and the next task starts from a better state.
Research Track

Human-AI co-evolution, published as a working research topic.

NOUS OS is using the student companion and Trading Brain proof bed to study how humans and AI can cooperate cognitively: memory, agency, boundaries, reflection, and measurable self-evolution.

Theory Anchor
Human-AI Symbiosis and Self-Evolution
The core framing for NOUS as an education and research system, not a generic automation stack.
Read page ->
Model v0
Co-Evolution Loop
A compact model of how human feedback, agent behavior, memory, and outcomes form a repeatable learning loop.
Open page ->
Metrics
Measuring Better Cooperation
Candidate metrics for human growth, agent adaptation, and relationship-level learning across repeated interactions.
View page ->
Study Demo
Student Sandbox v1
A browser-based 20-minute trial for hints, source checks, privacy boundaries, and final student reflection.
Launch sandbox ->
The Problem

Most agent systems can execute.
Very few can evolve.

Sessions restart from zero. Corrections disappear. Knowledge accumulates without trust. As agent count grows, coordination degrades and learning stops compounding.

💭
No persistent memory
Before: session ends → knowledge lost
After: episodic memory + semantic index
🎲
Unverified knowledge
Before: hallucinated facts treated as truth
After: confidence scores + decay + verification
📈
O(N²) coordination chaos
Before: 10 agents = manageable, 100 = collapse
After: O(N) event mesh, 183 agents, 67ms
🔄
Human judgment ignored
Before: AI override = feedback lost forever
After: every correction trains the next decision
The Flywheel

Every interaction makes the system smarter

This section shows the full NOUS OS loop: intent, trusted recall, coordinated execution, outcome writeback, and human correction.

01
💡
Intent
You express a goal. Aria frames intent and sets the task.
›
02
🧠
Trusted Recall
TrustMem retrieves trusted memory before the agent acts.
›
03
⚡
Coordinated Execution
Synapse routes work across agents while memory shapes the decision path.
›
04
📝
Outcome Writeback
Success, failure, and quality signals are written back into TrustMem.
›
05
🔁
Human Override
Corrections become future system intelligence instead of disappearing with the session.
TrustMem Flywheel

TrustMem is not a memory feature. It is the learning loop.

This section zooms into TrustMem specifically. It shows how memory participates before, during, and after every task — so agent behavior is shaped by history, corrected by humans, and improved over time.

TrustMem × Agent continuous interaction
Every task leaves the next task in a better cognitive state.
Before the task

Trusted retrieval shapes the starting point

When a task arrives, TrustMem retrieves episodic memory, verified knowledge, user preferences, and prior corrections. The agent does not start from zero; it starts from a trust-scored cognitive state.

During the task

Memory changes the decision path

Retrieved memory is not passive context. It changes priority, risk judgment, routing, and action selection. TrustMem influences how the agent thinks, not just what it can quote.

After the task

Outcomes become reusable intelligence

Successes, failures, and quality signals are written back as structured episodes. A one-off task becomes a future advantage instead of evaporating at the end of the session.

01
Task arrives
Aria frames intent and asks TrustMem what history matters before acting.
→
02
Trusted retrieval
TrustMem returns relevant episodes, verified knowledge, and prior corrections.
→
03
Decision shaped
The agent's reasoning, routing, and risk judgment are conditioned by memory.
→
04
Outcome captured
Success, failure, quality, and human corrections are logged as structured episodes.
→
05
Memory governed
Verification, decay, and promotion update what the system should trust next time.
better retrieval → better judgment → better outcome → better next run
retrieve → shape judgment → write back → improve next run
Human in the loop

Corrections are training signals

Human override is not treated as an exception. It is the highest-value signal in the system. Every veto, correction, and preference update becomes future behavioral guidance.

Memory governance

Verification, decay, and promotion keep memory clean

TrustMem does not simply accumulate more data. It uses verification, confidence scoring, temporal decay, and promotion so the system learns in the right direction instead of getting noisier over time.

Result

The agent gets better, not just bigger

The result is a compounding loop: better retrieval → better judgment → better outcomes → better memory → better next judgment. That is why TrustMem is the learning flywheel of NOUS OS.

TrustMem is the learning flywheel of NOUS OS. It retrieves trusted memory before each task, shapes reasoning during execution, captures outcomes and human corrections afterward, and updates memory quality through verification, decay, and promotion. It turns every human-agent interaction into trusted, evolving intelligence.
Components

Three layers.
One cognitive system.

Each layer is independently useful and platform-agnostic. NOUS OS is the compounding integration that connects them.

🧠
TrustMem
Memory Layer

Verified persistent memory for multi-agent AI. Knowledge trust scores, temporal decay, cross-agent verification.

Hit@5 Retrieval 62% → 100%
MRR 0.518 → 0.944
Verification Coverage 0% → 100%
github.com/jupiturliu/trustmem
⚡
Synapse
Signal Layer

Event-driven agentic service mesh. O(N) coordination replacing O(N²) P2P chaos. Budget-aware model routing.

EventBus Throughput 290K msg/s
Concurrent Agents 183 · 67ms startup
Coordination O(N) vs O(N²)
github.com/jupiturliu/synapse
MCP Portable
🏛️
Aria
Consciousness Layer

The human intent layer — understanding goals, preserving alignment, and surfacing cognitive friction. Currently running on OpenClaw, designed to be MCP-portable to any runtime.

Integration tests 44 / 44 ✅
Stage 2: aria-tools MCP In progress
Stage 3: Agent Manifest Q2 2026
github.com/jupiturliu/nous-os
Open Research

Built on measured component results

NOUS OS publishes demo metrics, component benchmarks, and a cross-repo release gate. Production hardening is still in progress.

📄
TrustMem Paper
Verified Persistent Memory for Multi-Agent AI
Hit@5: 62% → 100% · MRR: 0.518 → 0.944
📄
Synapse Paper
Event-Driven Agentic Service Mesh
290K msg/s · O(N) coordination · 183 agents
Roadmap

Where we're going

Hardening the human-AI learning loop before expanding the surface area.

✅ Done
Current — First-vertical proof consolidation
DomainEvaluator protocol · TradingEvaluator evidence wiring · dashboard evidence source · release gate green · nousos.ai live
Next
Reviewed outcome loop
At least three reviewed Trading Brain outcomes flow through the evaluator into tracked dashboard snapshots.
Then
External viewer review
A student, parent, teacher, or researcher can reproduce the demo and explain the boundary lessons without coaching.
Deferred
Surface expansion
Second verticals, multi-tenant packaging, and new top-level dashboard surfaces stay out of scope until the proof loop closes.
Early Access

Follow the research build

We're inviting early reviewers to test the demo, challenge the boundary model, and help shape the next research loop.

Join Waitlist
Built by Liu Fei · Open Source · MIT License