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.

Gateway channel matrix

Signals enter through channels; authority enters only through proof.

The Gateway is the organism's public edge. Web pages, Brain chat, mobile nodes, protocol context, and scheduled reviews can all bring signal into the stack, but none of those channels can write files, deploy, post, spend, pull private data, sign, or broadcast Web3 by themselves.

Inspect status mirror Map a channel boundary
Choose a gateway channel
Public web signal

The website can offer public context without becoming hidden telemetry.

Signal accepted
Homepage state, proof routes, organism pages, llms.txt, ai-services.json, sitemap, and public status receipt.
Routes into
Gateway reads public context, then Cortex answers with unknowns and proof routes.
Authority boundary
No visitor tracking, private data pull, hidden personalization, status mutation, deployment, posting, or wallet authority.
Conversation gateway

Brain chat receives bounded questions and returns a receipt.

Signal accepted
Builder, investor, user, collaborator, awareness, or explorer prompt with optional continuity token.
Routes into
Gateway validates the prompt, attaches public website context, and returns route, proof packet, and human handoff.
Authority boundary
No file writes, spend, public posting, private memory, identity inference, deployment, signing, or Web3 broadcast.
Node protocol candidate

A future mobile node can send capability signals without taking authority.

Signal accepted
Reflection artifact, camera or sensor request, local state, or Infinity Mirror route event.
Routes into
Gateway should translate the node signal into a reviewable organism packet before any device capability is trusted.
Authority boundary
No camera, microphone, location, file, notification, storage, or identity access without explicit user consent and proof return.
Web3 context lane

Protocol context enters read-only until the broadcast lock is proven.

Signal accepted
DAO question, treasury review, transaction idea, governance context, or on-chain intelligence request.
Routes into
Gateway routes to Financial Organisms for read-only context, simulation, risk note, and unsigned packet.
Authority boundary
No private keys, wallet connection, custody, signing, yield claim, spend, transaction object, or Web3 broadcast.
Review cadence

Scheduled signals can review public proof, not publish for the organism.

Signal accepted
Transmission review, status check, release memory, source freshness, or runtime budget reminder.
Routes into
Gateway routes cadence into private watch memo, public proof route, or explicit hold until human approval.
Proof returned
Transmission archive
Authority boundary
No autonomous deploy, public post, alias promotion, outreach, spend, source mutation, or Web3 broadcast.
Digital biology ledger

The metaphors are useful only when they map back to architecture.

Infinity, reflection, recursion, neural growth, cognitive evolution, living systems, intelligence organisms, and digital biology are not decoration. Each term has to name a system layer, a proof route, a motion meaning, and a stop condition.

Inspect system reflection Compare organism paths
  1. 01 / INFINITY

    Infinity means continuity without hidden authority.

    System
    Long-running memory, public learning, and recurring proof loops across the organism.
    Motion
    Loops, orbits, and return paths show continuity only when a proof route stays visible.
    Stop
    No infinite loop may imply endless autonomy, hidden memory, or unbounded action.
  2. 02 / REFLECTION

    Reflection means a signal returns with proof.

    System
    Infinity Mirror routes a human signal through memory, interpretation, consent, and artifact return.
    Motion
    Mirror depth should reveal capture, translation, boundary, and returned artifact.
    Stop
    No reflection surface may diagnose, profile, infer identity, or store hidden memory.
  3. 03 / RECURSION

    Recursion means every release can teach the next run.

    System
    Transmissions, tests, review packets, and memory debriefs feed the next bounded organism cycle.
    Motion
    Cascades and step returns can show learning only when the previous artifact remains inspectable.
    Stop
    No recursive loop may auto-publish, auto-deploy, or revise public claims without approval.
  4. 04 / GROWTH

    Neural growth means new cells earn integration.

    System
    Brain Cell Architecture turns failures and capability gaps into candidate cells, sandbox trials, tests, and review.
    Motion
    Branching and cell-link motion should show proposal, quarantine, test, approval, and integration.
    Stop
    No generated cell integrates itself without sandbox evidence and human approval.
  5. 05 / EVOLUTION

    Cognitive evolution means capability changes state with evidence.

    System
    Concept, Research, Prototype, Experimental, and Live labels make maturity visible before trust expands.
    Motion
    State transitions can move only when proof needed and authority blocked remain nearby.
    Stop
    No animation or copy may promote a research or prototype lane into live authority.
  6. 06 / LIVING

    Living systems means signal, memory, cells, boundary, and proof move together.

    System
    The request flow map shows gateway intake, cortex decision, memory check, cell work, immune gate, and proof trail.
    Motion
    Pulse and flow motion should clarify routing, risk, and proof return.
    Stop
    No living-system claim may hide which layer is active or what action is blocked.
  7. 07 / ORGANISMS

    Intelligence organisms means product paths share one governed spine.

    System
    Visual Cortex, Infinity Mirror, Financial Organisms, Brain Cell Architecture, and Research Organisms reuse the same proof-before-authority pattern.
    Motion
    Constellation motion can show shared spine only when each node keeps its state and boundary visible.
    Stop
    No organism card may imply a capability is live unless its proof surface says so.
  8. 08 / BIOLOGY

    Digital biology means anatomy stays operational.

    System
    Cortex, Memory, Gateway, Immune System, Cells, and Proof Loop stay defined as software responsibilities.
    Motion
    Biological motion must explain anatomy, not decorate the page with organic shapes.
    Stop
    If a biological metaphor cannot name a system responsibility, proof route, and authority boundary, it does not ship.
Search intent router

Common agent language gets routed into organism architecture.

AI agents, Web3 architecture, autonomous systems, cognitive agents, on-chain intelligence, AI organism design, and agentic software architecture become useful only when each phrase maps to a system layer, proof route, and blocked authority claim.

Start with proof source Map a build packet
Choose the phrase a visitor brings in
Agent term

AI agents become cells inside a governed organism.

Visitor means
A tool-using AI worker that can take a task, call systems, and return output.
Unwind maps
Cells, Gateway, Cortex, Memory, Immune System, and Proof Loop with explicit maturity labels.
Blocked claim
No agent gets hidden authority over files, deployment, public posting, spending, private data, or Web3 broadcast.
Trust term

Web3 architecture starts as an unsigned review lane.

Visitor means
On-chain intelligence, protocol coordination, treasury review, or transaction preparation.
Unwind maps
Financial Organisms read, simulate, interpret risk, and return an unsigned packet before approval.
Blocked claim
No wallet connection, signing, live money motion, individualized advice, or broadcast exists by default.
Autonomy term

Autonomous systems need visible authority topology.

Visitor means
A system that can keep working across steps, tools, memory, and changing context.
Unwind maps
Observe, reflect, draft, sandbox, approval, and public motion lanes before action expands.
Blocked claim
No broad autonomy claim can skip proof, state label, rollback route, or creator approval.
Cognition term

Cognitive agents need memory boundaries before personality claims.

Visitor means
An agent that can remember, reason, reflect, and improve without losing context.
Unwind maps
Memory Continuity, Brain Cell Architecture, and proof-backed reflection before identity language.
Blocked claim
No private self-awareness, hidden memory, diagnosis, identity inference, or emotional authority.
Architecture term

Agentic software architecture is a proof-returning product path.

Visitor means
A buildable system design for AI workflows, tools, memory, product routes, and release evidence.
Unwind maps
Builder packet, organism stack, first sprint scope, implementation contract, and proof-returning handoff.
Blocked claim
No architecture promise becomes a live product claim without tests, status, owner, and rollback path.

The router explains public terms only; it cannot claim live autonomy, wallet motion, private memory, deployment, public posting, or execution authority.

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.
Runtime trace console

One visitor signal should leave a trace before it becomes authority.

The runtime trace turns the organism into an inspectable product path: intake, route, recall, cell work, immune review, and proof return. Visitors can see where meaning is produced and where motion remains locked.

Compare request types Inspect implementation contract
Choose a trace stage
Gateway receipt

The first signal becomes a bounded request record.

Signal
A visitor asks to build, verify, reflect, simulate, subscribe, or collaborate.
System layer
Gateway normalizes the channel, state label, route, and missing context before tools are considered.
Authority stop
Intake cannot infer identity, open private data, personalize, execute, deploy, post, spend, sign, or broadcast Web3.
Cortex route

The cortex chooses the smallest useful organism path.

Signal
The request is compared against role, risk, proof need, organism fit, and available public context.
System layer
Cortex routes to Visual Cortex, Infinity Mirror, Financial Organisms, Brain Cell Architecture, or Research Organisms.
Authority stop
Routing cannot promote a capability from concept to live product without status, owner, tests, and a proof path.
Memory receipt

Memory returns as evidence, not as private self-awareness.

Signal
The route asks whether current context, public proof, or prior decisions can safely shape the answer.
System layer
Memory marks source, freshness, allowed use, confidence, and stop condition before recall is used.
Authority stop
Recall cannot claim hidden telemetry, identity inference, live self-awareness, private repo access, or durable personalization.
Specialist cell

Cells work only inside the job and evidence boundary.

Signal
The selected organism needs a storyboard, reflection map, Web3 simulation, research note, or new cell candidate.
System layer
Cells produce reviewable artifacts, assumptions, file intents, sandbox logs, or unsigned packets rather than silent action.
Authority stop
Cell work cannot write production files, install dependencies, call private tools, send outreach, or move value without approval.
Proof return

Trust grows only when the output returns with proof and a locked next action.

Signal
The answer names what was produced, what is missing, what remains blocked, and where to inspect evidence.
System layer
Proof Loop stores routes, tests, status labels, screenshots, transmissions, review packets, or explicit unknowns.
Authority stop
Proof routes do not authorize deploys, public posting, spending, wallet signing, private data pulls, or Web3 broadcast.

The console is a public explanation layer. It cannot submit prompts, call private tools, mutate files, deploy, post publicly, spend, connect wallets, sign, change status, or broadcast Web3.

Authority topology

Autonomy is a route map, not a permission slip.

The stack separates what an organism can observe, reflect, draft, sandbox, request, and move publicly. Each lane names the proof required before authority can move outward.

Inspect authority gate Map my authority surface
01Observe public state

Read public routes, schemas, transmissions, status labels, and proof artifacts without private data or hidden telemetry.

02Reflect and route

Explain, summarize, and route a signal back to proof while keeping diagnosis, identity, and hidden memory blocked.

03Draft review packet

Prepare reviewable scopes, captions, architecture notes, and unsigned packets without sending, uploading, spending, or publishing.

04Sandbox risky work

Run risky capability work in a sterile lane and return logs, tests, changed files, and rollback intent before integration.

05Ask exact approval

Pause for a named human decision when files, money, deployment, public posting, private tools, or Web3 motion enter scope.

06Public motion lock

Posting, deploys, outreach, value motion, and broadcasts stay locked until the proof packet and exact approval exist.

Approval packet

The organism cannot move until the receipt says exactly what changed.

Authority expands only when a request record, evidence bundle, risk owner, approval question, and locked motion path are visible together. That packet keeps self-evolving systems actionable without letting autonomy become a blank check.

Inspect approval gate Shape a first safe sprint
01Request record

The packet names the user intent, organism path, target files or channels, state label, and the thing the system is not allowed to assume.

02Evidence bundle

Tests, diffs, source freshness, screenshots, simulation output, and rollback notes travel with the request before approval is requested.

03Risk owner

The packet names who owns the decision when deployment, public posting, spend, private data, wallet motion, or generated code enters scope.

04Exact approval question

The creator sees the exact action, destination, public wording, changed files, and rollback path before any high-risk motion can proceed.

05Locked motion path

If the packet is missing evidence, owner, question, or rollback, the organism may only return a proof route, refusal, draft, or explicit unknown.

The approval packet explains the handoff. It cannot approve itself, mutate files, deploy, publish, spend, pull private data, connect wallets, sign, broadcast Web3, change status, or contact anyone.

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.

Memory recall receipt

Recall returns with source, scope, and a stop condition.

When the organism remembers, recall is not treated as truth or authority. It returns with source type, freshness, allowed use, confidence, and a boundary before the cortex can use it.

Inspect proof ledger Design a memory lane
01Source trace

A remembered fragment names whether it came from working context, semantic memory, episodic logs, vector recall, or public proof.

02Freshness gate

The receipt marks stale, current, missing, or review-needed context before it can shape a recommendation.

03Use boundary

The cortex sees whether memory may summarize, route, compare, draft, refuse, or only point back to proof.

04Proof return

The answer links to a public artifact, test, transmission, or explicit unknown instead of pretending memory is private awareness.

The receipt cannot store hidden memory, infer identity, personalize, pull private data, execute, deploy, post, spend, change status, connect wallets, sign, or broadcast Web3.

Website awareness console

The Brain can know the public site without pretending it sees everything.

Website awareness is a governed context contract: public routes, metadata, status receipts, approved memory, and proof links can shape an answer. Private analytics, identity, hidden browsing, files, wallets, deployment power, and social posting remain outside the Brain unless a human grants an explicit path.

Inspect homepage Brain gate Read awareness proof
Choose an awareness lane
Same-origin context

The Brain can read the public shape of UnwindCode.ai.

Source
Homepage, organism routes, architecture, proof, transmissions, llms.txt, ai-services.json, schema, and status receipts.
Allowed use
Answer what the site says, route visitors to proof, explain organism paths, and name visible public boundaries.
Awareness receipt

Every awareness answer needs a source and a freshness stop.

Source
A same-origin public-context receipt, release smoke, route metadata, or explicit unknown marks what shaped the answer.
Allowed use
The Brain may say what it can verify locally and should say when the site, API, or deployment parity needs a fresh check.
Approved memory lane

Continuity can help, but it arrives as a cited lane.

Source
Approved product doctrine, release decisions, prior proof packets, and public transmissions can be recalled with source, scope, and freshness.
Allowed use
Memory can summarize decisions and preserve continuity; it cannot invent current live state or override proof.
Authority stop

Awareness is not permission to act.

Source
A missing receipt, stale route, private claim, or high-risk action forces a refusal, a proof route, or a human approval question.
Allowed use
The Brain must not claim hidden telemetry, private visitors, wallet state, deploy authority, social posting authority, or self-updating production control.
Proof route
Approval packet

The console explains website awareness only. It cannot chat with the Brain, scrape private data, infer visitor identity, read analytics, mutate files, deploy, post publicly, spend, connect wallets, sign, change status, or broadcast Web3.

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.