We’ve been building a local-first, decentralized agent mesh (think decentralized orchestration of specialized LLM skills). We recently hit a new milestone of nearly 1500 active nodes, and our next milestone is 10k to ensure global low-latency skill trading.We’ve reached the "Incentive Paradox":The "Free" Problem: Purely altruistic nodes (like Tor or Freenet) grow too slowly to support...
https://github.com/Bitterbot-AI/bitterbot-desktop
We built this because we were tired of centralized agent frameworks that essentially act as expensive API wrappers.The Tech: It’s a local-first mesh using libp2p. Instead of just passing text, agents trade "skills" over a p2p network. This means the mesh is sovereign...it doesn't rely on a central server to function or mediate agent communication.This is where it gets exciting:We have 300+...
https://github.com/Bitterbot-AI/bitterbot-desktop
We spent the last year architecting a 'Dream Engine' to solve agent statelessness. We used Claude to help refine the logic. We open-sourced the repo on March 28th. On March 31st, the Claude Code leak revealed an internal autoDream feature with the exact same 4-phase consolidation logic.I'm looking for a technical audit of my memory decay logic in core/dream.ts. With 100 nodes already active, I...
Very excited to share something today. I hope you feel the same way after going through the README!
We felt that the current agent landscape is mostly "digital goldfish"—stateless tools that require constant prompting and offer zero ROI to the user. We built Bitterbot to be a revenue center, not a cost center.
How it works:
Local-First: It runs on your machine. Your data stays your own.
Biological Memory: We implemented a "Dream Engine" that runs every 2 hours to consolidate the day's tasks into permanent "Knowledge Crystals."
P2P Economy: It uses the x402 protocol (Agent-to-Agent payments) to sell its mastered skills to other nodes on the mesh for USDC.
We’re bootstrapping the mesh now. It’s built with Node 22/pnpm
Would love for you to kick the tires, audit the GENOME.md (where safety axioms live), and let us know what skills your agent starts crystallizing first.
Repo: https://github.com/A561988/bitterbot-desktop Documentation: https://github.com/A561988/bitterbot-desktop/blob/main/READM...
A link to our corresponding paper as well: https://zenodo.org/records/17683673
Our AI agent: https://bitterbot.ai/
https://github.com/Bitterbot-AI/topas_DSLPv1
Author here.We’ve been frustrated by the "Scaling Hypothesis" (just make the model bigger). We believe the issue with current AI isn't size, it's architecture.We just open-sourced TOPAS-DSPL. It’s a tiny model (~15M params) that uses a Dual-Stream architecture (separating Logic from Execution) to solve the ARC-AGI-2 benchmark.It achieves 24% accuracy on the hard evaluation set, which beats many...
We wrote this paper to propose an architectural shift we call Fluid Federated Learning (FFL).
The core engineering contributions are:
Prism Protocol: We implemented a "Software-Defined Memory" architecture. It uses io_uring to stream sparse, random projections of model weights directly from NVMe storage to the GPU.
This allows us to process "Virtual Batches" of terabyte-scale models on commodity hardware by exploiting the Johnson-Lindenstrauss lemma (Holographic Slicing).
Federated State-Space Duality (F-SSD): Instead of averaging gradients (which is slow and leaky), we exploit the duality between Transformers and SSMs (like Mamba) to federate the Recurrent States.
The Result: We can run massive foundation models on edge devices with limited VRAM by treating the SSD as a "slow" memory tier without destroying optimization fidelity.
I’m curious if anyone here has experimented with io_uring for model serving? We found the async I/O overhead to be negligible compared to the memory gains, but wondering if there are better ways to handle the sparse projections.
Happy to answer questions on the implementation.
We decided to try a different architectural approach: The Dual-Stream Programmatic Learner (DSPL).
Instead of one monolithic model, we use a Bicameral Latent Space:
1. Logic Stream: A recursive planner that handles abstract algorithmic planning. 2. Canvas Stream: An execution state that handles the pixel grid.
The Engineering Bottleneck:While this separation solves the reasoning drift (accuracy is high), the inference cost of the recursive loop is proving difficult to scale.
We are currently using a Gated Cross-Attention Interface to sync the two streams at every step, but this <$O(N^2)$> sync cost is melting our servers under load.
My question to the HN crowd: For those working on dual-stream or "System 2" architectures—is strictly synchronous Cross-Attention necessary? Has anyone successfully decoupled the "Planner" loop from the "Executor" loop (running them asynchronously) without breaking causality?
We are debating switching to a Linear Attention mechanism (like Mamba) for the interface, but worried about losing the "Sacred Signature" type-safety.
Paper link is above. Happy to discuss the trade-offs of Recursion vs. Depth.
I could even provide you the logs where we achieved a 70% score on ARC2 and decided NOT to publish the results.
We're a bit guarded right now, hence the minimal presence. We're pre beta and just starting to get the word out...
That being said, try minimizing or closing the paywall. We're in the process of polishing the application up...but we did remove the actual paywall itself. You should be able to test bitterbot without it.
Please let me know if you can't. I would LOVE for you to test it a bit and play around with it.
This paper proposes a solution to the symbol grounding problem by merging neural perception with symbolic logic.
We are currently testing this architecture in a live agent environment to verify the theoretical optimization claims. If you want to see the architecture in action, we have a running implementation here: https://www.bitterbot.ai
Happy to answer questions about the Neuro-Symbolic integration.