Talk agents into existence.
The runtime ships today. The conversation is where it goes. A Rust core holds the invariants. You author in a handful of Python decorators. State lives on one plane — and the dashboard breathes with it.
rust core · python authoring · frozen json-rpc/a2a wire · 320-test proof gate
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 Egg
Author the surface in Python decorators. Typed args, docstring contracts, requires_confirmation on anything that matters.
create_app Larva
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 Chrysalis
@box state persists and streams — one shared plane, no cache layer, no drift. @store memory survives restarts.
The UI breathes Butterfly
The TypeScript SDK renders box-driven widgets and a full dashboard shell. The agent writes a box; every subscribed widget updates live.
State that renders. UI that remembers.
An agent writes a box — a typed piece of its own state. That single write is both the persistence layer and the UI update. Try it: this demo is the actual pattern, miniaturized.
- boxes ▸ ui/state ← { mood: "curious" } — persisted · 1 widget re-rendered
Everything an agent product needs, in one runtime.
Eight things you stop building yourself the day you adopt Psyche. All shipped, all behind the proof gate, all one system.
Boxes — the box plane
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.
Confirmation gates
requires_confirmation → destructiveHint. Important actions pause for a human. A typed property of the tool — not a prompt you hope the model respects.
Typed tools
Docstrings become schemas; envelopes are validated at the wire. Malformed intent never reaches your functions.
Brains
A brain is config, not plumbing. Point at any provider; swap models without touching a single tool.
Stores
@store memory survives restarts, model swaps — and, one day, bodies.
Sub-agent delegation
get_mind() is one line. Each sub-agent has its own tools, brain, and boundaries.
The frozen 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.
And 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.
Meet Aristotle. He’s alive in the repo.
A small survival sim played by a real LLM through psyche tools: vitals that drift, a clickable world map, a 3D avatar, a live dashboard. He is not a mock-up — he’s the runtime demonstrating itself. Every pane below is the product surface: boxes rendered as widgets.
- hunger is a curve, not an event. eat before the curve wins.
- the west pool is water. remembering that.
- → tools/call look_around {}
- ← receipt #291 ok · 4 tiles noted
This embed is a simulation of the shipped example — run the real one: docs tutorial 01. 3D avatar included.
Models propose. Typed systems enforce.
Natural language is intent, not authority.
The model’s words never touch your systems directly. Between intent and action sits a typed envelope, a gate, and a receipt.
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 } } }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.
Orchestration frameworks run graphs.
Psyche runs products.
LangGraph, CrewAI and Microsoft’s Agent Framework are excellent at what they aim for: orchestrating model calls. Psyche’s bet is the layer they stop at — everything an agent needs to be a product. It isn’t either/or: whole frameworks run inside Psyche as loop plugins — a LangGraph plugin ships today, with Claude Code and Codex terminal plugins next.
| Capability | LangGraph · CrewAI · MS Agent Framework | Psyche |
|---|---|---|
| Persistent state plane | checkpoints & memory add-ons | ✓ the box plane — state is the live UI |
| Product UI out of the box | bring your own frontend | ✓ TS SDK: box-driven widgets + dashboard shell |
| Confirmation-gated tools | DIY per project | ✓ typed: requires_confirmation → destructiveHint |
| Sub-agent delegation | graphs & crews | ✓ get_mind() — one line, own tools and boundaries |
| Stable client protocol | library APIs move release to release | ✓ frozen JSON-RPC / A2A wire |
| Money-grade safety posture | out of scope | ✓ gates, receipts, no server-side signing by design |
If you need a graph executor inside a bigger system, those are strong choices — and they still work here. If you’re shipping an agentic product — state, UI, safety and all — that’s what Psyche is for.
the chrysalis in the corner just opened — your move
This is called the transformation of things.
Clone the repo, run Aristotle, and author your own agent in a handful of decorators before your coffee cools.
Backing the long arc instead? The Fairloom thesis →