The runtime for agents that outlive their stack

Your AI stack will change.
Your agent shouldn’t.

Everyone is building agents on moving ground.

Model agnosticOpenAI, Anthropic, Gemini, OpenRouter, whatever wins next.

Framework agnosticLangGraph, custom loops, and other orchestration run inside Psyche.

Storage agnosticSwap or extend persistence without rewriting the agent.

Surface agnosticWeb today, with voice and embodied interfaces later.

See Psyche running See what ships today

rust core · python authoring · stable json-rpc/a2a · typed gates · 248-leg proof gate

The intelligence will change.
The agent should survive it.

Models change.
Frameworks change.
Storage changes.
Interfaces change.

The things that change

Models

OpenAI
Anthropic
Local
Future

Frameworks

LangGraph
CrewAI
Custom loops
Future

Storage

Postgres
S3
Custom
Future

Surfaces

Web
Voice
VR / AR
Robotics

Psyche

Agent Card
State
Authority
Evidence
Memory
Capabilities
Stable protocol / identity

The agent that stays

● ships today ◌ not shipped

Psyche separates the durable agent from the machinery underneath it.

The shipped example Shipping today

This isn’t an architecture diagram.
Wake one up.

A real model plays a survival sim through Psyche tools. Every pane below is product surface.

0 · vitals · @box, livet+0

health82

hunger41

energy67

mood → curious · the map keeps not ending

last write · boxes ▸ vitals · 11msnext decision · t+2

1 · world · click a tile to send him(6,4)

2 · tail -f thoughts.log

hunger is a curve, not an event. eat before the curve wins.
the west pool is water. remembering that.

3 · wire · last frames

→ tools/call look_around {}
← receipt #291 ok · 4 tiles noted

[psyche]0:vitals1:world2:thoughts3:wire aristotle: curious · up 00:00 · 248/248 ✓

Live stateWorldThoughtsWirePersistent boxesTool callsProof gate

or click the map, and operator pings become tools/call frames

Run it locally.

from the repo README

# 1 · build the rust core into the importable `nodeai`

git clone https://github.com/AristosMesotes/psyche.git && cd psyche

python -m venv .venv && source .venv/bin/activate

pip install "maturin>=1.10,<2.0"

maturin develop --release

# 2 · build the @psyche/* typescript sdk

cd psyche_sdk && npm install && npm run build:sdk && cd ..

# 3 · terminal one: the backend on :8010

cd examples/human/backend && python serve.py

# 4 · terminal two: the ui on :3100

cd examples/human/frontend && npm run dev

# 5 · the proof gate

bash python/nodeai/prove.sh

248 parity legs. 0 failures. Run the same proof gate yourself.

The repo is private today. Request access and these commands are the whole path.

The panes above simulate the shipped example so the page works without a server. The commands run the real one, 3D avatar included.

The runtime surface shipping today

One runtime. The pieces you stop rebuilding.

Eight things you stop building yourself the day you adopt Psyche. All shipped, all behind the proof gate, all one system.

Signature

self.box(…)Guests today42

Boxes persistent state + UI

One shared plane where agent state persists and the UI updates live. The agent writes a box; the dashboard breathes. No cache layer, no websocket glue, no drift.

openrouter/gpt-oss-120bswap the model, keep the mind

Brains swappable models

A brain is config, not plumbing. Point at any provider; swap models without touching a single tool.

process exits …memory intact ✓

Stores persistent memory

@store memory survives restarts, model swaps: and, one day, bodies.

"just send it" TYPED ✓

Typed tools validated action contracts

Docstrings become schemas; envelopes are validated at the wire. Malformed intent never reaches your functions.

tool: pay_invoiceHELD: asks first

Confirmation gates human control where it matters

requires_confirmation → destructiveHint. Important actions pause for a human. A typed property of the tool: not a prompt you hope the model respects.

Sub-agent delegation

get_mind() is one line. Each sub-agent has its own tools, brain, and boundaries.

frozen

agentJSON-RPC / A2Aui

Frozen JSON-RPC/A2A wire

A stable protocol between runtime and clients. Build UIs against it once; it doesn’t move under you.

Widgets + dashboard

The TypeScript UI SDK ships box-driven widgets and a full agent dashboard shell. Real product UI, not a debug console.

From code to operating agent Shipping today

From a handful of decorators to a running mind.

One system end to end. No glue services, no second state store, no separate UI backend to keep in sync.

`@tool` + `@brain`

Author the surface in Python decorators. Typed args, docstring contracts, requires_confirmation on anything that matters.

create_app

create_app serves your agent over the frozen JSON-RPC/A2A wire. Dashboards, CLIs, and sibling agents all speak the same frames.

State in boxes

@box state persists and streams: one shared plane, no cache layer, no drift. @store memory survives restarts.

The UI breathes

The TypeScript SDK renders box-driven widgets and a full dashboard shell. The agent writes a box; every subscribed widget updates live.

psyche: ~/fairloom/greeter

Today you write the right pane yourself. The left pane is what Maker is for.

you · intent.txt north star

I want a greeter.

It should welcome guests by name,

think with a big open model,

and show me everything it does ,

live, in a real UI.

# that's it. that's the spec.

psyche · greeter.py shipping today

# psyche serves the nodeai.api surface: drop-in

from nodeai.api import Agent, tool, brain

@tool(["Greeter"])

def greet(self: Agent, name: str):

"""Greet a guest by name."""

return f"Hello, {name}!"

@brain(["Greeter"])

def greeter_brain():

return {"client": {"provider": "openrouter",

"model_name": "openai/gpt-oss-120b"}}

$ psyche run greeter

create_app ............ ok

wire mounted .......... json-rpc / a2a (frozen)

healthz ............... 200

proof gate ............ 248 passed · 0 failed

greeter ............... awake → dashboard on :8010

status

awake

box · greetings

last reply

"Hello, Ada!"

The box plane: the signature primitive shipping today

State that renders.
UI that remembers.

agent · a @tool body

self.box("ui/state", {"mood": "curious"})

boxes ▸ ui/state ← { mood: "curious" } persisted · 1 widget re-rendered

One write. One source of truth. Persistence and interface stay synchronized.

No second UI state.
No websocket glue.
No cache reconciliation.
No agent/database/dashboard drift.

Agents shouldn’t be allowed to grade their own homework.

Before the action Shipping today

Natural language is intent, not authority.

What the model says

“Sure: the invoice checks out, so I’ll go ahead and pay the $1,200 to ACME now and let you know once it’s done…”

Fluent. Confident. And on its own: just text.

What the wire enforces

{ "jsonrpc": "2.0", "id": 7,
  "method": "tools/call",
  "params": {
    "name": "pay_invoice",
    "arguments": { "invoice_id": "ACME-0142",
                   "amount_usd": 1200 } } }

Held by your gate: the runtime delivered a typed envelope, not money

requires_confirmation → destructiveHint: the gate ladder runs before any side effect, and every consequential action leaves a receipt. By design, psyche ships no signing primitive: money-grade logic lives inside tools you own, behind permissions and approvals.

After the action Coming next

A receipt is not an outcome.

Tool200 OK
System of recordDid the intended state actually change?
Verified Held Exception

Models propose. Psyche enforces. The world confirms.

The model is replaceable.
These aren’t.

State	What is true?
Authority	What may happen?
Evidence	What actually happened?
Agent Card	What is this agent supposed to be?

● ships today ◌ not shipped

Psyche isn’t another framework you have to bet the company on.

OpenAI / Anthropic / Local Your intelligence

LangGraph / CrewAI / Custom Your orchestration

Psyche

CRM / ERP / Ledger / Database / Infra Your systems of record

Keep your stack. Add the durable layer.

Where Psyche sits

Orchestration frameworks run graphs.
Psyche runs products.

Capability	Agent frameworks	Psyche
Model orchestration	✓	✓ / embeds
Persistent application state	partial / add-on	✓
Product UI	bring your own	✓
Authority gates	DIY	✓
Stable client protocol	library API	✓
Model replacement	varies	core design
Framework replacement	usually no	core design

Built to remove four kinds of lock-in.

ModelSwap the brain.

FrameworkRun LangGraph or another controller inside Psyche.

StoragePersistence is an implementation choice.

SurfaceWeb is one interface, not the identity of the agent. Vision

The model lost. Psyche didn’t care.

A learned navigator was underperforming in the Minecraft environment.
We replaced it with a classical navigator.
The higher-level agent didn’t change.
Its identity didn’t change.
Its capabilities didn’t change.
Its product didn’t need to be rewritten.

That’s model independence in practice.

Psyche today → where Psyche goes next.

Run

Today

Operating runtime.

state
memory
typed tools
gates
receipts
sub-agents
model plugins
framework plugins
storage plugins
stable wire
web UI

Verify

Evidence-governed completion.

Outcome Contracts
external verification
verified completion
exception semantics
evaluation data

Make

Then

Talk agents into existence.

natural language goals
Agent Card
semantic diffs
organization generation

Embody

Long term

One mind. Many bodies.

voice
AR/VR
games
robotics

● ships today ◌ not shipped

Psyche Maker Coming next

Tell Psyche what changed.

01
You
“Also track interested buyers and overdue follow-ups.”
02
Psyche Maker
03
Agent Card diff

car-sales-manager.card.diff

+ interested buyers

+ follow-up dates

+ overdue workflows
04
Updated agent
Running

You changed the meaning.

Psyche changed the implementation.

Psyche is what comes after the demo.

Your agent works. Now you need it to survive.

Model replacement
Persistent state
Recovery

You’re letting it touch real systems.

Permissions
Typed tools
Receipts
Verification

You’re turning it into a product.

UI
Multiple agents
Stable protocol
Infrastructure

Build freely. Pay when Psyche becomes part of your business.

Personal / research / open source Free

Build agents. Experiment. Learn. Contribute.

Startups Free under $1M revenue

Use Psyche to build the business before Psyche becomes a line item.

Commercial Pay when you succeed

Commercial licensing or small revenue participation above the threshold.

Enterprise Custom

Private deployment, support, SLAs, compliance, negotiated licensing.

Psyche should be free enough to become infrastructure before it becomes a budget line.

Models are becoming commodities.Agent products aren’t.

When models are interchangeable, value moves upward into the system that owns continuity: state · identity · authority · evidence · capabilities · interface.

Embodiment Vision

Eventually, the screen is just another body.

PsycheOne persistent mind

WebDashboardToday

VRAvatarFuture

RobotBodyFuture

Today, Psyche gives an agent a stable operating identity across software interfaces. The long-term architecture extends that same identity, state, memory, authority, and capability boundary into virtual and physical bodies.

One mind. Many bodies.

Your next model shouldn’t require your next rewrite.

Request Psyche Access

Run Aristotle

Free for personal use and qualifying startups. Commercial licensing when you scale.

Technical reference Plugin registration code and test methodology.

Plugin registration

Every tier is a plugin registry you can extend: @brain_type · @loop_type · @storage_type. Write your own Claude Code loop plugin, your own S3 store, a decentralized-compute brain: a decorator and a duck-typed contract register it by name. No core changes, no forks.

a storage plugin, in full

# python/nodeai/plugins/storage/localfs_storage.py

from nodeai.plugins.storage import IStoragePlugin, StorageCapabilities, storage_type

from nodeai.mind.box_persist import MISSING

@storage_type(name="LocalMemory")

class LocalFsStorage(IStoragePlugin):

def capabilities(self) -> StorageCapabilities:

return StorageCapabilities(durable=True, atomic_write=True)

def put(self, partition, namespace, key, value):

... # temp file, then os.replace: atomic on POSIX and Windows

def get(self, partition, namespace, key):

... # a miss returns MISSING, never None

Ships today: LocalMemory (filesystem) and SqliteMemory.

Test methodology

bash python/nodeai/prove.sh runs 248 legs behind an exact-count gate: every green assertion is paired with a broken oracle that must fail, and a silently skipped leg is red. It is one of 17 gates in the repo, which carries no CI configuration.

Your AI stack will change.Your agent shouldn’t.

Everyone is building agents on moving ground.

The intelligence will change.The agent should survive it.

Models

Frameworks

Storage

Surfaces

This isn’t an architecture diagram.Wake one up.

One runtime. The pieces you stop rebuilding.

Boxes persistent state + UI

Brains swappable models

Stores persistent memory

Typed tools validated action contracts

Confirmation gates human control where it matters

Sub-agent delegation

Frozen JSON-RPC/A2A wire

Widgets + dashboard

From a handful of decorators to a running mind.

@tool + @brain

create_app

State in boxes

The UI breathes

State that renders.UI that remembers.

Agents shouldn’t be allowed to grade their own homework.

Models propose. Psyche enforces. The world confirms.

The model is replaceable.These aren’t.

Psyche isn’t another framework you have to bet the company on.

Orchestration frameworks run graphs.Psyche runs products.

Built to remove four kinds of lock-in.

The model lost. Psyche didn’t care.

Psyche today → where Psyche goes next.

Tell Psyche what changed.

Psyche is what comes after the demo.

Build freely. Pay when Psyche becomes part of your business.

Personal / research / open source Free

Startups Free under $1M revenue

Commercial Pay when you succeed

Enterprise Custom

Models are becoming commodities.Agent products aren’t.

Eventually, the screen is just another body.

Your next model shouldn’t require your next rewrite.

Plugin registration

Test methodology

Your AI stack will change.
Your agent shouldn’t.

The intelligence will change.
The agent should survive it.

This isn’t an architecture diagram.
Wake one up.

`@tool` + `@brain`

State that renders.
UI that remembers.

The model is replaceable.
These aren’t.

Orchestration frameworks run graphs.
Psyche runs products.