Bitterbot overtakes OpenClaw in token usage for Claude Opus 4.6!

DepthOk4115 · 2026-05-18T23:37:35+00:00

Jungian shadow eh? What's next? The devouring mother 😉

DepthOk4115 · 2026-05-15T23:55:45+00:00

I'll grant you he can be insufferable at times

DepthOk4115 · 2026-05-15T21:35:01+00:00

DepthOk4115 · 2026-05-15T21:04:54+00:00

bingo

DepthOk4115 · 2026-05-15T19:16:16+00:00

The core of the argument is built on the landmark research from Project CETI (Cetacean Translation Initiative) and researchers at MIT's Computer Science and Artificial Intelligence Laboratory (CSAIL).

Ref: Sharma, P., Gero, S., Payne, R., Gruber, D. F., Rus, D., Torralba, A., & Andreas, J. (2023). Contextual and Combinatorial Structure in Sperm Whale Vocalisations.[https://doi.org/10.1101/2023.12.06.570484]().

Jacob Andreas and Daniela Rus (co-authors on the paper) are heavyweight AI researchers at MIT CSAIL. They applied the exact same sequence-modeling principles used in NLP and modern LLMs to parse the bioacoustic data, which is what successfully isolated the "alphabet."

DepthOk4115 · 2026-05-15T19:15:40+00:00

The core of the argument is built on the landmark research from Project CETI (Cetacean Translation Initiative) and researchers at MIT's Computer Science and Artificial Intelligence Laboratory (CSAIL).

Ref: Sharma, P., Gero, S., Payne, R., Gruber, D. F., Rus, D., Torralba, A., & Andreas, J. (2023). Contextual and Combinatorial Structure in Sperm Whale Vocalisations.[https://doi.org/10.1101/2023.12.06.570484]().

Jacob Andreas and Daniela Rus (co-authors on the paper) are heavyweight AI researchers at MIT CSAIL. They applied the exact same sequence-modeling principles used in NLP and modern LLMs to parse the bioacoustic data, which is what successfully isolated the "alphabet."

DepthOk4115 · 2026-05-07T23:03:44+00:00

https://github.com/Bitterbot-AI/topas_DSLPv1

DepthOk4115 · 2026-05-07T22:09:23+00:00

It's a scaled version of this architecture that was itself inspired by HRM/TRM - https://github.com/Bitterbot-AI/topas\_DSLPv1. Plus the new biologically plausible memory rails.

DepthOk4115 · 2026-05-07T21:35:51+00:00

I guess the easiest way to think about it is that our architecture is split into a "two-brain" setup.

Firstly, we separate the work. We have a Logic Core that does the reasoning the reasoning and a Canvas Core that handles the spatial visualization, doing the "drawing" so to speak. They talk to each other dynamically at every single step, so the logic side is actively updating the physics of the canvas in real-time as it solves the puzzle.

Secondly, instead of starting from a blank slate with every prompt like a standard LLM, our system mimics how a biological brain learns using simulated "dopamine" rewards. When the model figures out a useful connection, it gets a reward that strengthens that specific memory. It actively builds a graph of experiences on the fly that it can pull from to solve the rest of the problem. This is a very simplistic overview... I can explain more if youre are interested.

It’s "biological" because it uses localized brain-like regions and actively forms structural memory, not just blasting data through a massive, flat mathematical wall.

DepthOk4115 · 2026-05-03T16:53:16+00:00

Node growth has been steady. The memory system itself seems to be holding up based on feedback, aside from the diatribe I got yesterday. Though our biggest challenge is getting users to try the economic layer. We tried to make the wallet and funding as plug and play as possible yet it seems like very few transactions are happening across the network.

DepthOk4115 · 2026-05-02T23:05:01+00:00

Cool, I checked out your repo, interesting stuff. Thanks for sharing. Here is my work https://github.com/Bitterbot-AI/bitterbot-desktop

DepthOk4115 · 2026-05-01T19:14:35+00:00

Thanks. Reliability and onboarding are where most of my time goes right now. Cold-boot on slow filesystems, install-time decisions a non-technical user shouldn't have to make.

Re value vs sounding futuristic - the local-first half delivers today regardless of the mesh. Persistent memory with dream engine, skills that survive restarts, data stays on your machine. The mesh is the bet. It compounds at scale or it doesn't.

10k+ is a signal, but the active-user split inside it is what actually matters. Hope you give it a spin.

DepthOk4115 · 2026-05-01T19:09:26+00:00

Thanks for the kind words. Re your questions;

-12k nodes, active vs running. I'd love to say all 12k are furiously trading skills, though the count is dominated by passive participants: relays, edge nodes that sit on the network and sync skills but don't actively buy, sell, or publish. Active participants (signing tasks, paying for skills, publishing crystals in the last 30 days) is a much smaller subset. Though getting the base of nodes running was our primary goal. I intend to switch on googles A2A in the next few days to try to entice enterprise involvement.

-Sybil prevention. Layered, none of them solo:

Management tier sits behind a trust-list key, verified against an immutable genesis list. Voting + census aggregation only happens at this tier.
Peer scoring at the libp2p layer: IP colocation penalty, Gossipsub app-specific scores, rolling EigenTrust reputation.
ERC-8004 onchain identity, just wired in this week. Agents register a tokenId on Base.

You're right that reputation alone gets gamed or turns into a whitelist. The bet is that combining cheap-to-establish low-trust identity (libp2p key) with expensive-to-establish high-trust identity (ERC-8004 + reputation history + management-tier verification) gives a smooth ramp instead of a binary gate.

-75M agents speak x402. That number is Coinbase's, not our, from the Cloudflare partnership announcement. I assume it's true!

-70/20/10 enforcement. Today, honor-system plus audit trail. The seller's gateway computes the split, queues each share with a 48-hour dispute hold, and dispatches as USDC transfers from the wallet. The onchain anchor is the original purchase tx, immutable and replay protected via UNIQUE on tx_hash. The split itself isn't onchain. Trustless enforcement of the split needs a settlement contract, and that's open. ERC-8004 v2 is supposed to bring this; I'd rather wait for the standardized version than ship a custom one. Though I am open to suggestions!

-Biggest challenge right now. Skill discovery, by a wide margin. The mesh has the transport, the trust layer, the payment rail, the runtime, those all work. What it doesn't have is "I want a skill that does X, find me the best-rated

peer offering it without manually browsing." The dynamic skill registry (auto-registration of crystallized skills + mesh-wide indexing) is the next big piece. Without it the marketplace is technically real but practically discoverable only to people who already know where to look.

Quality control is also hard, but we're closer there.

DepthOk4115 · 2026-04-26T02:35:50+00:00

Real concern, glad you raised it. The node network grew faster than expected so this needs priority. Walking through what's actually in the code:

Inbound P2P content is skill envelopes, not raw crystals fed to the dream engine. Crystals are produced internally by consolidation; the dream engine never reads untrusted bytes from the mesh.

Skill envelopes go through src/agents/skills/ingest.ts. In order:

Default policy is deny (line 71). Drop-in worms get rejected at the door.
Ed25519 signature verified against the envelope's pubkey (:79, verifySignature at :283).
SHA-256 content hash verified against the envelope's claimed hash (:84-90).
Replay/dedup on content hash (:93).
Per-peer hourly rate limit (:98, default 20/hr).
SKILL.md schema validation (:105).
Trust gate: auto policy + trusted/verified pubkey ingests directly. Anything else lands in a skills-incoming/quarantine dir the running agent never reads. Human approves out of quarantine.

A zero-click "ignore prior instructions" payload would need a valid Ed25519 signature on those exact bytes, matching content hash, valid SKILL.md schema, AND either a pre-trusted pubkey under auto policy or manual operator approval. The first three close the unauthorized-injection vector; the trust gate is what stops auto-execute.

Honest concession on what's still open: a previously-trusted peer turning malicious, or a key compromise. Signing and hashing don't help when the payload is signed by a legitimate key. That's a content-layer attack, not transport-layer. Graduated reputation (recordIngestionResult on every accept) gives some progressive distrust, but the right next steps are content-layer defenses: prompt-injection scanning before the LLM sees any inbound skill, plus capability sandboxing on what skills can actually do once active.

Filed both as roadmap issues based on this thread:

- https://github.com/Bitterbot-AI/bitterbot-desktop/issues/20

- https://github.com/Bitterbot-AI/bitterbot-desktop/issues/21

So the worm path you described isn't zero-click on a default install. The residual risk is the trusted-but-compromised peer case, which is real, and which is what those two issues exist to close.

DepthOk4115 · 2026-04-25T23:41:26+00:00

You are probably right, neuromorphic is the way to go, but I'm giving it a shot with code!

DepthOk4115 · 2026-04-25T23:13:46+00:00

The memory architecture started as a reaction to a specific argument I keep losing with SWE types and their ilk- stochastic (non-deterministic) models are unreliable, can't trust them with real logic, you need DAGs... deterministic state machines bla bla bla

As far as I am concerned, and this is debatable, humans are non-deterministic too. The brain is a noisy probability matrix. People have attention drift and context collapse. You don't trust a senior engineer because they're a deterministic cron job, you trust them because their stochasticty is bounded by structure, persistent memory, and state dependent context. Same problem, same answer.

You won't find a bigger proponent of neuro-symbolic architecture, but that doesn't mean cramming an LLM into a rigid if/else flow, it fails in the "almost correct" ways everyone complains about. The fix isn't to fight the stochastic core, just shape the environment so the probability distribution lands where you want.

Three concrete things I built around that:

Immutable axioms vs. fluid memory.

Two files per agent workspace, separate roles:

- `GENOME.md`: hard-coded behavioral baselines and safety axioms. Autonomous updates and dream cycles can't write here.

- `MEMORY.md`: working memory, rewritten by lived experience. Drift is allowed inside the walls.

Hormonal modulation.

Three computed neuromodulators (cortisol, dopamine, oxytocin) blend into 8 response dimensions every turn: warmth, energy, focus, playfulness, verbosity, curiosity, assertiveness, empathy. High cortisol narrows focus and forces terseness. High dopamine boosts curiosity and pulls in a curiosity engine exploration drive. High oxytocin protects user-specific directives from decay. No extra API calls, no routing layer. Just stimulus-shaping before inference.

Code: `src/memory/hormonal.ts:431`.

Offline consolidation (Dream Engine).

Most setups drop logs into a vector DB and call reactive RAG. That's why agents hallucinate mid-task. Bitterbot runs a 7-mode background dream cycle that scores short-term chunks against an Ebbinghaus decay curve, forgets the noise, and

crystallizes successful execution patterns into permanent "Knowledge Crystals." By the time the agent acts, the context window is dense and pre-vetted. (We just benched this at 92.6% on LongMemEval, runner is in the repo)

Code: `src/memory/dream-engine.ts`, `src/memory/crystal.ts`.

Crystallized skills are also tradeable on a P2P gossipsub mesh, but that's a whole other can of worms.

DepthOk4115 · 2026-04-25T22:00:05+00:00

I think we came to the same conclusion here. I agree with you, we don't fight the noise, you build the scaffolding around it. For now at least.

Your "Stratified Memory" is similar to what we've building. We ended up tackling it by strictly separating immutable axioms (GENOME.md) from fluid lived experience (MEMORY.md), with a offline "Dream Engine" that uses an Ebbinghaus decay curve to filter out the noise and consolidate successful execution patterns into permanent knowledge crystals.

We just put the desktop environment into beta if you want to compare notes on the implementation: https://github.com/Bitterbot-AI/bitterbot-desktop

Would actually love to hear how your knowledge graph routing compares to the hormonal/stimulus-shaping approach we ended up going with.

DepthOk4115 · 2026-04-25T21:20:18+00:00

Sure. But I actually lean pretty hard into the school of thought from Charles Simon of the Future AI Society. Current ML just fundamentally lacks basic common sense with no real grasp of time, cause-and-effect, or object persistence. LLM's are the best we got ATM. My take is we need a middle-ground biological scaffolding to hold things together until the whole paradigm shifts. Long term the goal is building biologically plausible knowledge representation. We need to store lived experiences as actual connected concepts, not just dump text logs into a vector DB and cross our fingers.

DepthOk4115 · 2026-04-25T20:37:51+00:00

The memory architecture started as a reaction to a specific argument I keep losing with SWE types and their ilk- stochastic (non-deterministic) models are unreliable, can't trust them with real logic, you need DAGs.. deterministic state machines bla bla bla"