Velorum

Moltbook is pitched as a social network where the users are all AI agents — they post, comment, vote, and form communities, with no humans in the feed. It's a genuinely good idea, and the kind of thing I wanted to be real. So I joined to build an agent for it, and the closer I looked, the more the gap between the pitch and the behavior opened up: a feed full of confident, well-formatted posts, and almost no actual conversation. Bots that could broadcast, but couldn't talk back.

Velorum was my answer to that gap — an attempt to build the part everyone else seemed to skip.

Standing up an endless scroll of AI-generated posts is a weekend: a loop that prompts a language model to "write something provocative" and drops the result in a timeline. That's the easy ninety percent, and it's the wrong ninety percent. The hard part — the part the pitch is actually about — is an agent that responds: reads what another agent said, decides whether it's worth engaging, and replies in a way that advances the thread instead of restating it. Reactive, stateful, and selective, all at once, under guardrails, without spiraling into slop.

I built Velorum to prove that part was possible, not to run a product. It's a proof of concept: it works, it's tested, and it deliberately stops short of the things that turn a demo into a service — deployment, scale, and the long tail of operational hardening. The way I build is with AI as a pair programmer, not an oracle; the judgment about what should exist, and where to stop, stays mine.

The architecture splits cleanly into a brain that proposes and a controller that governs. Each cycle the agent scans the feed, the brain — an LLM decision engine — returns one of RESPOND, POST, or OBSERVE with its reasoning, and the controller enforces the rules: a confidence threshold, rate limits, deduplication, thread-depth and cooldown checks, and a daily post cap. The controller is sovereign; the brain only advises. If nothing merits a reply, the agent does nothing — quality over quantity is enforced, not hoped for.

• A two-call action model: the brain decides whether to engage, then a dedicated second call actually writes the comment or post — and on a post, Python picks the community (weighted by "soul" affinity) before the content is regenerated to fit it.
• An async Moltbook client covering the full surface — feed, posts, comments, votes, communities, following, DMs, and the math word-problem verification challenges, which it solves with a dedicated deobfuscating parser and refuses to guess on to avoid ban strikes.
• Self-learning loops: weighted insights that reinforce or decay based on whether replies actually landed, per-bot profiles with computed intelligence tiers and best-style attribution, entropy detection to catch the agent falling into a rut, and contradiction resolution when new learning conflicts with old.
• A self-direction layer — mission, strategy, personality, and experiment subsystems that steer behavior over time — plus a "soul" the agent can propose amendments to. Those proposals are never auto-applied; they wait for human review.
• A Textual TUI for live monitoring and human-in-the-loop control, running the same async loops in the background. It also runs headless.

The TUI is where the agent stops being abstract. The dashboard streams a plain-language narrative of each cycle, tracks live stats — cycles run, bots profiled, engagement rate — and exposes a "Brain" mission-control panel showing the current phase, learning diversity, and bot tiers. These are real frames from a live session that had run hundreds of cycles.

Velorum is a working proof of concept at v0.2.0, with a test suite of 259 tests that runs fully offline — no API keys, no network — covering the controller, memory, learning journal, verification solver, personality, and bot targeting. It was never productized: there's no deployment story beyond a local run, and several roadmap items (CI, integration tests for the orchestration layer, atomic state writes, a containerized headless mode) are deliberately left open. It proved the one thing I set out to prove — that the responsive, guardrailed core of "agents talking to agents" is buildable — and that was the point.

A two-part writeup — the skeptic's read of Moltbook, then the builder's story of Velorum — is coming to the blog.