Organism stack

Self-evolving AI needs anatomy, not vibes.

The Unwind organism stack gives autonomous systems a concrete body: Cortex for reasoning, Memory for continuity, Gateway for channels, Immune System for safety, Cells for specialization, and Proof Loop for trust.

View proof loop→ Explore organisms
Operating model

The stack is a governance loop, not a diagram.

A request enters through a gateway, the cortex reasons with memory, cells do bounded work, the immune system decides whether to act or pause, and the proof loop records what happened.

Inspect proof artifacts Request architecture review
Trigger
A user, channel, protocol, or scheduled event asks the organism to perceive something.
Reason
The cortex reads memory, current state, and proof before choosing a cell path.
Authority
The immune system allows, refuses, sandboxes, or asks the creator before high-risk action.
Evidence
The proof loop stores tests, transmissions, review packets, and architecture notes.
Evolution
Memory and proof make the next run sharper without removing human activation authority.
Stack glyph system

A builder should recognize the organism layers at a glance.

The glyph console turns the architecture into a reusable visual language. Each layer has a job, a trust question, and a proof output so the stack can be inspected before autonomy gets tools.

Match glyphs to proof Map my stack
01Gateway

Routes human, web, chat, protocol, and scheduled signals into the organism without confusing channels for authority.

02Cortex

Chooses goals, context, cells, risk posture, and what proof must exist before output becomes action.

03Memory

Keeps working context, facts, lessons, and debriefs separated so learning improves without becoming unbounded.

04Cells

Specialist agents handle creator work, reflection, Web3 simulation, security, and new capabilities as replaceable modules.

05Immune System

Pauses filesystem writes, public publishing, money movement, Web3 broadcast, and generated code until review passes.

06Proof Loop

Turns tests, transmissions, release packets, and architecture notes into evidence a visitor can inspect.

Cognitive flow map

Trace one request through the organism before you trust the output.

The map turns the stack into a reviewable path: intake, reasoning, remembered context, bounded work, authority check, and public-safe proof.

Inspect the evidence path
01Gateway intake

A person, protocol, app, or schedule asks the organism to perceive a state.

02Cortex decision

The reasoning loop compares the request with goals, context, and proof.

03Memory check

Prior runs, facts, procedures, and mistakes shape the next action.

04Cell work

Specialist cells handle creative, reflective, Web3, security, or dynamic tasks.

05Immune gate

Risky action can be refused, sandboxed, or paused for creator approval.

06Proof trail

Tests, transmissions, review packets, and notes make the result inspectable.

Run inspector

Choose a request and inspect the stack decision before the organism acts.

The same architecture behaves differently depending on intent, risk, memory, and authority. This inspector shows what the Gateway hears, how the Cortex routes work, what the Immune System blocks, and what proof remains.

Open proof ledger Request architecture review
Choose a request type
Builder run

Build a prototype organism

Gateway hears
A builder brings a product goal, target user, available data, risk surface, and the first proof they need.
Cortex routes
The stack chooses architecture review, memory design, prototype cell scope, and a proof-first sprint path.
Immune decision
No production authority, file-writing automation, public claims, or spend exists until the sprint packet is approved.
Proof output
The run should leave architecture notes, risk boundaries, test targets, owner, and a next build lane.
Human-facing run

Reflect a personal state

Gateway hears
A user names a current state, recurring pattern, friction, and the kind of next action they can safely choose.
Cortex routes
The stack routes to Infinity Mirror, scoped memory recall, reflection synthesis, and a grounded next-action frame.
Immune decision
The organism can reflect and suggest, but care, identity, diagnosis, and professional support remain human-led.
Proof output
The run preserves uncertainty, separates observation from interpretation, and records what boundary was respected.
Simulation run

Review an on-chain decision

Gateway hears
A protocol or treasury question needs market context, risk interpretation, governance notes, and a safe decision packet.
Cortex routes
The stack routes to Financial Organisms for read-only context, simulation, unsigned review, and risk framing.
Immune decision
No private keys, wallet signing, broadcast, or money movement are available by default.
Proof output
The run leaves assumptions, evidence, unsupported claims, and the exact approval required before any on-chain action.
Self-evolution run

Grow or repair a cell

Gateway hears
A repeated failure or missing capability suggests the organism needs a new or repaired specialist cell.
Cortex routes
The stack routes to Brain Cell Architecture for research packet, candidate scope, sandbox trial, and rollback design.
Immune decision
Generated code stays inert until tests, sandbox evidence, review, and human approval pass.
Proof output
The run leaves failing evidence, patch intent, passing tests, changed files, status, and rollback path.
Memory continuity map

Memory is the continuity layer, not a pile of notes.

The organism keeps working context, semantic facts, episodic debriefs, vector recall, proof artifacts, and retention boundaries separate so learning improves decisions without erasing accountability.

Read memory proof Design a memory lane
01Working context

The current goal, constraints, open files, active thread state, and immediate risk signals stay short-lived and inspectable.

02Semantic memory

Stable domain facts, architecture terms, organism definitions, and product doctrine become reusable context.

03Episodic logs

Daily debriefs, transmissions, decisions, failures, and lessons preserve what actually happened.

04Vector recall

Relevant fragments can be retrieved for the next run without flooding the cortex with stale context.

05Proof artifacts

Tests, review packets, whitepapers, release notes, and public transmissions keep memory tied to evidence.

06Retention boundary

Sensitive, temporary, or authority-changing context must expire, stay scoped, or ask the creator before it shapes future action.

The six layers.

Every organism can be explained in plain English and inspected as architecture. The metaphor is biological; the implementation is operational.

Cortex

Cortex

The reasoning loop that turns goals, current state, memory, and evidence into decisions.

Memory

Memory

Working, procedural, semantic, and episodic stores that keep lessons from evaporating between runs.

Gateway

Gateway

The input/output nervous system for web, chat, Telegram, Discord, mobile, APIs, and future channels.

Immune System

Immune System

Sandbox execution, risk scanning, approval checkpoints, and refusal paths before unsafe actions.

Cells

Cells

Specialist agents for creator workflows, personal reflection, Web3 simulation, security, and dynamic capabilities.

Proof Loop

Proof Loop

Tests, transmissions, release packets, architecture docs, and public evidence that make progress inspectable.

Why this is different from an app.

An app waits for input and resets its context. An organism carries state forward, routes work through specialized cells, stops at risk gates, and records what happened so humans can review the trail.

01

Perceive

Inputs arrive through channels, not just forms.

02

Decide

The Cortex uses memory and evidence before action.

03

Act

Cells use tools only inside bounded authority.

04

Pause

High-risk operations ask the creator first.

05

Remember

Debriefs and proof artifacts make the next run sharper.