Brain Cell Architecture - The Brain That Builds Brains

Product path

Self-evolution needs an immune system.

Brain Cell Architecture gives generated capability a path through research, sandbox tests, approvals, source control, and proof before it becomes part of an organism.

Map the architecture Read the whitepaper

Stage: Experimental pattern for new organism capabilities.
Input: Domain problem, risk boundary, memory needs, tools, and proof requirements.
Cells: Research, architecture, sandbox, approval, integration, and proof loops.
Boundary: Generated code is inert until tests, approvals, and source-control review pass.
Proof: The checkpoint whitepaper and proof ledger explain how cells grow under governance.

Capability ledger

What Brain Cell Architecture can grow, what stays quarantined, and where proof lives.

Before lifecycle visuals turn self-evolution into a story, the page names the growth boundary: signal, research packet, sandbox trial, approval, integration, and rollback. A candidate cell can be proposed; it cannot join the organism until proof says yes.

01 / Signal
Turn repeated failure into a scoped cell brief.

The architecture can notice when a prompt loop is no longer enough and convert the pattern into a bounded problem packet.

Input
Repeated failure, missing capability, domain need, operator context, and constraints.

Output
A scoped problem packet and candidate cell brief.

Blocked claim
No hidden self-modification, autonomous code execution, or unreviewed filesystem write.

Proof route
Follow the lifecycle map
02 / Research
Research the cell before code earns attention.

A generated class is not trusted because it sounds plausible. The research packet names assumptions, interfaces, tests, risk, and rollback first.

Memory boundary
Only reviewed failures, source context, public docs, and proof artifacts inform candidate design.

Output
A research packet with assumptions, sources, interfaces, tests, and rollback plan.

Blocked claim
No generated cell becomes trusted because it compiles or reads well.

Proof route
Read the cell swap protocol
03 / Sandbox
Run the candidate as evidence, not authority.

The sandbox can test fixtures, failure traces, dependency behavior, and repair attempts without granting host or production authority.

Tool boundary
No host command, money movement, deployment, public posting, wallet call, or production load.

Output
Test results, failure traces, risk note, diff intent, and proof packet.

Blocked claim
No external side effect or capability joining runtime on first pass.

Proof route
Inspect the runtime console
04 / Integration
Integrate only after review can still say no.

A passing cell remains replaceable. Approval, source control, documentation, memory summary, proof ledger, and rollback decide whether it joins.

Approval boundary
Human review, source-control history, proof packet, and rollback path approve or refuse integration.

Output
An integrated or refused cell with visible proof and a rollback route.

Blocked claim
No irreversible self-evolution, hidden memory write, authority expansion, or unreviewed autonomy.

Proof route
Inspect the authority gate

Failure triage

Not every failure earns a new cell.

The organism first classifies the failure: prompt gap, missing tool, unsafe request, or durable cell candidate. Only durable, repeatable gaps can move toward research and sandbox proof.

Follow lifecycle map Review permission ladder

Choose a failure class

01Prompt gap 02Missing tool 03Unsafe request 04Cell candidate

Clarify, do not mutate

The failure belongs to language or instructions.

Signal: Repeated ambiguity, missing context, or a prompt that asks the wrong question.
Route: Improve the prompt, docs, examples, or intake path before proposing code.
Proof: Transcript, revised wording, expected answer shape, and what changed.
Blocked: No new cell, code write, memory write, dependency install, or runtime authority.

Research interface first

The system lacks a bounded capability.

Signal: The task repeatedly needs a tool, parser, data source, or integration that does not exist.
Route: Write a research packet, interface contract, fixture need, and risk class.
Proof: Tool boundary, sample input/output, denied authority, and first sandbox fixture.
Blocked: No dependency install, private tool call, credential access, or production route.

Freeze and ask

The request touches authority before proof exists.

Signal: Filesystem, money, public posting, private data, Web3 movement, deployment, or status mutation appears.
Route: Refuse, pause, or ask the creator for a narrow approval with exact destination.
Proof: Risk class, blocked action, approval need, and stop condition.
Blocked: No execution, write, deploy, spend, post, private pull, wallet call, or broadcast.

Candidate may proceed

The gap is repeatable enough to become a cell brief.

Signal: A bounded failure recurs with clear input, output, owner, constraints, and testable outcome.
Route: Move to research packet, lifecycle map, sandbox fixture, approval owner, and rollback route.
Proof: Problem packet, first test, risk note, fixture, and integration refusal path.
Blocked: No integration until sandbox proof, explicit approval, source review, and rollback exist.

Cell lifecycle

A new capability stays quarantined until proof says it can join the organism.

Brain Cell Architecture makes neurogenesis inspectable: a failure or need becomes research, then a bounded candidate cell, then sandbox evidence, immune review, human approval, and only then integration.

Read cell proof Design a cell lane

01Problem signal

The organism detects a repeated failure, missing capability, or domain need that cannot be solved by prompting harder.

02Research packet

The domain, risks, tools, memory needs, authority limits, and proof requirements are written down before code exists.

03Candidate cell

A proposed cell is generated or implemented as inert source, scoped to one job and one authority boundary.

04Sandbox trial

The candidate runs in a sterile environment with tests, logs, dependency checks, and no default host authority.

05Immune review

Risk gates decide whether the cell can proceed, needs changes, should be refused, or must ask the creator.

06Integrated skill

Only approved, tested cells become part of the organism, with source control, rollback path, and public proof attached.

Runtime console

Pick a cell request and see how the organism keeps mutation governed.

A brain that builds brains needs a visible operating surface. Every request is routed through signal, cell path, proof bar, and authority boundary before the new capability can touch the organism.

Inspect proof gates Design a governed cell

Choose a cell request

01Design cell 02Sandbox repair 03Approval gate 04Integration proof

Research packet

New capability design

Signal: A repeated task failure shows the organism needs a specialized cell instead of another prompt.
Cell path: Research writes the domain, inputs, memory needs, dependencies, fallback, and one narrow job for the candidate.
Proof bar: The packet must include acceptance tests, risk notes, rollback path, and what evidence would prove the cell useful.
Authority boundary: The request can propose source shape, but no generated code is trusted, run, or integrated by default.

Sandbox packet

Repair a failing cell

Signal: A candidate cell fails tests, exceeds scope, or touches a dependency it was not allowed to use.
Cell path: The repair loop reads logs, narrows the patch, reruns the sterile trial, and keeps host authority unavailable.
Proof bar: The console preserves failed test evidence, the exact fix intent, passing output, and remaining uncertainty.
Authority boundary: Sandbox repair can change candidate code only inside the review lane; production files remain locked until approval.

Creator gate

Pause on risky authority

Signal: The cell wants to write files, spend money, post publicly, call a private tool, or broadcast a Web3 action.
Cell path: The immune layer freezes execution, explains the request, names the destination, and asks the creator for a narrow decision.
Proof bar: Approval evidence includes command intent, affected surface, risk class, human decision, and the refusal path.
Authority boundary: High-risk actions stay inert unless explicit human approval grants that exact action for that exact destination.

Proof packet

Integrate a passing skill

Signal: The candidate has passed tests, stayed in scope, and produced evidence that it improves the organism.
Cell path: Integration adds source-control review, documentation, rollback route, memory summary, and public proof link.
Proof bar: The release packet names tests, changed files, operating boundary, owner, status, and what still remains experimental.
Authority boundary: A passing cell can join the organism only as a bounded skill with review history, rollback, and observable proof.

Permission ladder

Self-evolution earns one permission at a time.

The ladder names what stays locked and what becomes allowed as a candidate cell moves from observed failure to proposed source, sandbox proof, creator approval, and limited integration.

Review evidence board Inspect integration gate

Choose a permission rung

01Observe 02Propose 03Prove 04Approve 05Integrate

Observed failure

A repeated failure becomes a cell question.

Locked: No source write, tool call, memory write, deployment, posting, spend, or Web3 action.
Allowed now: The organism may name the failure pattern and request a research packet.
Proof return: Problem packet with evidence, exclusions, owner, and first test.
Stop condition: If no repeated failure or domain need exists, no cell is proposed.

Candidate proposed

The cell is inert source, not authority.

Locked: No host execution, dependency install, private data pull, or production route.
Allowed now: A narrow interface, tests, rollback plan, and risk class can be drafted.
Proof return: Research packet and diff intent before any execution.
Stop condition: If scope or dependencies are vague, the candidate stays in quarantine.

Sandbox proof

Execution is evidence inside the sterile lane.

Locked: No filesystem write outside fixtures, external side effect, deploy, publish, spend, or wallet call.
Allowed now: Fixture replay, logs, dependency checks, and failure repair can run inside sandbox.
Proof return: Passing tests, failed attempts, risk note, and rollback path.
Stop condition: If a high-risk command appears, freeze and ask the creator.

Creator decision

Authority opens only for the exact approved action.

Locked: No broad autonomy, hidden memory, public post, money movement, private tool call, or Web3 broadcast.
Allowed now: A human can approve or refuse one bounded write, integration step, or proof update.
Proof return: Decision receipt with action, destination, risk, and refusal route.
Stop condition: If approval is missing or vague, the cell remains inert.

Limited integration

A passing cell joins as a replaceable skill.

Locked: No irreversible self-evolution, status promotion, dependency expansion, deployment, posting, spending, or Web3 authority.
Allowed now: Reviewed source, docs, memory summary, registry entry, and rollback route can land.
Proof return: Integration receipt with owner, tests, changed files, route, state, and rollback.
Stop condition: If rollback or owner is missing, integration is refused.

Sandbox evidence board

A passing cell must leave evidence, not vibes.

The sandbox turns mutation into proof: fixture replay, dependency fence, diff scope, immune review, and rollback path are visible before a candidate cell can approach integration.

Inspect the authority gate Read the checkpoint

01Fixture replay

The candidate must run against known failures and show the exact behavior that changed.

02Dependency fence

Imports, tools, network calls, filesystem access, and secrets stay named before any expanded authority exists.

03Diff scope

The proposed patch states touched files, intent, rollback route, and what stays outside scope.

04Immune review

Risk class, blocked actions, approval need, and refusal path are recorded before the cell can move forward.

05Rollback proof

A cell can integrate only when rollback, owner, status, tests, and proof route remain inspectable.

Cell integration gate

A candidate cell joins only as a bounded skill with proof memory.

After sandbox evidence, the organism still has to decide how the cell may exist: quarantine state, staging fixture, registry memory, approval owner, rollback route, and integration receipt stay visible before runtime authority changes.

Review sandbox evidence Inspect authority gate

01Quarantine state

The candidate remains inert until status, owner, failed attempts, and blocked authorities are visible.

02Staging fixture

The first integration target is a fixture path, not the live organism, so behavior can be replayed without production authority.

03Registry memory

The cell entry records purpose, inputs, outputs, dependencies, risk class, proof route, and rollback owner.

04Approval owner

A human or review lane must name the exact authority being granted before filesystem, deploy, public, spend, or Web3 motion can unlock.

05Integration receipt

The cell can join only with tests, review history, source diff, rollback route, state label, and public proof return.

Evolution memory receipt

A new cell is remembered as proof, not power.

After sandbox evidence and integration review, the organism writes a receipt: what changed, why it changed, which tests passed, who approved it, what rollback exists, and which authorities remain locked.

Review integration gate Inspect growth boundary

01Patch record

The receipt names the failure pattern, changed files, diff scope, rejected alternatives, and the one job the cell is allowed to perform.

02Test memory

Passing fixtures, failed attempts, dependency fence, runtime budget, and regression checks become memory before the cell can be reused.

03Approval owner

The receipt records who approved the exact authority, which powers stayed denied, and when review must happen again.

04Rollback route

A graduated cell keeps a disable path, owner, health signal, public proof route, and unknowns so future runs can refuse or revert.

The receipt cannot install cells, write files, deploy, change status, mutate a registry, pull private data, spend, post publicly, connect wallets, sign, or broadcast Web3.

Growth boundary checkpoint

A self-evolving cell must prove growth without gaining hidden authority.

This checkpoint translates the architecture into a release rule: a candidate can graduate only when its proposal, sandbox proof, creator decision, rollback, and public proof route are visible. Anything else stays quarantined.

Review permission ladder Run awareness checkpoint

01 / Proposal

The cell starts as a scoped request.

Graduation evidence: Problem packet, owner, first test, dependencies, refusal path, and rollback intent.
Still locked: No execution, file write, memory write, dependency install, or runtime state change.

02 / Sandbox

The cell runs only where failure is contained.

Graduation evidence: Fixture replay, passing tests, failed attempts, dependency fence, diff scope, and risk note.
Still locked: No host authority, production load, deploy trigger, public post, spend, wallet call, or broadcast.

03 / Approval

The creator decision must be exact enough to refuse.

Graduation evidence: Human decision, destination, action scope, risk class, state label, and refusal record.
Still locked: No broad autonomy, hidden memory, status promotion, private data pull, or authority expansion.

04 / Proof memory

Graduation leaves a public return path.

Graduation evidence: Registry entry, changed files, tests, rollback route, owner, proof URL, and unknowns.
Still locked: No private self-awareness claim, live telemetry claim, self-deploy, public posting, spend, or Web3 motion.

Cell growth protocol.

01

Research

Define the domain, constraints, risks, and proof requirements.

02

Architecture

Map inputs, memory, tools, authority, and fallback behavior.

03

Sandbox

Run code in a sterile environment before trusting it.

04

Approval

Filesystem, money, and public channels pause for human consent.

05

Proof

Tests and transmissions leave an inspectable trail.

Why it matters.

Self-evolving systems need more than generation. They need a nervous system, an immune system, and an audit trail. Brain Cell Architecture is how Unwind turns neurogenesis into governed software instead of uncontrolled mutation.

Read the whitepaper

The brain that builds brains.