We gave AI agents real, living biological brains.
Organoid Claw lets you build autonomous agents that run on living human brain organoids instead of LLMs. No GPT, no Claude — actual neurons. ~10k of them, on electrodes, in a lab in Switzerland.
We use FinalSpark's Neuroplatform for the wetware side and OpenClaw for the agent framework. This repo is the glue between them.
Forked from FinalSpark-np/np-docs.
- Site: organoidclaw.com
- X: @organoidclaw
OpenClaw agents normally call an LLM api for every decision. We swapped that out for biological neural tissue.
rough flow:
agent gets task -> we encode it into electrical pulses ->
send pulses to organoid via finalspark api ->
organoid does its thing (actual synaptic processing) ->
we read the electrode response -> decode that into a decision ->
agent acts on it -> if it worked, we hit the organoid with dopamine
the organoid literally learns from this. dopamine strengthens whatever pathways fired during the good decision. same mechanism as a human brain learning. except its in a petri dish in vevey.
no retraining. no fine-tuning. it just... adapts.
git clone https://github.com/losientopy/organoidclaw.git
cd organoidclaw
pip install -r requirements.txt
# copy the example config and add your keys
cp config.example.json config.jsonyou need a finalspark api key. its $500/mo for neuroplatform access — go to finalspark.com. you also need an openclaw instance running locally.
edit config.json:
{
"finalspark": {
"apiKey": "your_key_here",
"endpoint": "https://api.finalspark.com",
"arrayId": 0,
"electrodes": 32,
"samplingRate": 30000
},
"openclaw": {
"gatewayUrl": "ws://127.0.0.1:18789",
"skillsDir": "~/.clawdbot/skills/organoidclaw"
},
"reward": {
"dopamineOnSuccess": true,
"uncagingWavelength": 365,
"rewardThreshold": 0.7
},
"encoding": {
"method": "frequency",
"maxAmplitude": 2.5,
"pulseDuration": 200,
"stimTimeout": 5000
}
}just give openclaw the repo url and it'll pull it in:
https://github.com/losientopy/organoidclaw
then talk to your agent normally. decisions route thru the organoid instead of an llm.
# the main one — full decision loop
python scripts/decide.py --task "should i buy SOL"
# poke the organoid
python scripts/stim.py --pattern buy_signal --array 0
# read whats happening
python scripts/rec.py --dur 500
# reward it (dopamine via uv light, yes really)
python scripts/reward.py --array 0
# is it alive?
python scripts/health.py
# watch it live
python scripts/mon.py --live"should i buy SOL rn"
"what does the organoid think about ETH"
"check health"
"show me recent decisions"
this is the hard part. how do you turn "should i buy SOL" into electrical signals a blob of neurons can process?
each organoid has 8 electrodes. 4 organoids = 32 electrodes total. we treat each electrode as a dimension. the amplitude + frequency + timing of pulses on each electrode encodes the semantics of the task.
the organoid responds with spike patterns. we measure where the activity concentrates (center of activity / CA) and how it shifts. that shift IS the answer.
if CA drifts right → positive signal (buy/yes). left → negative (sell/no). concentrated spikes → high confidence. scattered → low confidence.
then we reward good outcomes with dopamine (literally UV light breaks open a molecular cage releasing dopamine into the organoid medium). over time it gets better at the tasks you reward it for.
| neurons/organoid | ~10,000 |
| organoids/array | 4 |
| electrodes/organoid | 8 (32 total) |
| sampling | 30 kHz, 16-bit |
| voltage accuracy | 0.15 μV |
| stimulation | 10 nA – 2.5 mA |
| reward mechanism | dopamine uncaging, 365nm UV |
| organoid lifespan | ~100 days |
| power vs silicon | ~1,000,000x less |
| location | Vevey, Switzerland |
native token. every organoid decision = fee. fees go into locked treasury permanently. soft burn. admin key burned. more usage = less supply, forever.
- wetware: FinalSpark
- agent layer: OpenClaw
- losientopy
Apache-2.0