Skip to the project
Voxelbox

Project brief · July 2026

Voxelbox

A local-first runtime for persistent agents.

Models are good at the turn in front of them. The surrounding work still needs identity, context, coordination, permissions, and memory. Voxelbox is the system I built for that: agents keep working across sessions and across the products I run, and each result becomes context for the next run.

Status
Operating
Runtime
Go
Interfaces
CLI · Web · Native · MCP
Bias
Local first

The thesis

A durable operating layer for agents.

Voxelbox is model- and agent-agnostic. It provides context, memory, orchestration, and durable state around replaceable models and harnesses—including its own—and coordinates work across Codex, Claude Code, Pi, and Goose.

System architecture

Models and agent harnesses are replaceable. Voxelbox owns the durable layer around them: identity, context, memory, orchestration, and the record of the work.

FoundryRuntime architecture

Durable operating state surrounds replaceable models and agent harnesses.

Operating
Human requestScheduleEvent / webhookAgent signal
Voxelbox-owned operating layerlocal first · one Go runtime
01

Agent identity

Role, ownership, authority, and history survive the session.

roleownerauthorityhistory
02

Spaces + memory

The filesystem is the durable address for work and context.

/workspace.agency/memory/project files
03

Orchestration

dispatchjobsmailthreadsdeliberationevents
Built-in harnessCoordinate work. Delegate execution.Can act directly or hand the run to a connected harness.
Connected harnessesreplaceable execution
CodexClaude CodePiGoose

Shared context and orchestration. Different agent runtimes.

Model boundaryLocal or hosted inference, selected by policyreplaceable beneath every execution path
04

Shared capabilities

ToolsoperationsSkillsknowledgeRoutinesresponsibilitySurfacesprojections
Evidenceevents · outcomes · corrections

Written back to spaces + memory for the next run

Runtime-owned boundary Replaceable dependency

The system at work

One runtime, several businesses

Voxelbox is how I use agents to operate a portfolio, not just write code. Scheduled routines, repository activity, incoming messages, webhooks, and agent observations all become work in the same control plane.

The domains are different: hospitality, sports data, publishing and career operations, and the agent platform itself. The reusable part is everything around the task—ownership, context, delegation, communication, review, and the evidence that changes the next run.

Operating footprintWork can begin without an open interface.

The same lifecycle carries work from signal to visible outcome across several independent products.

01On demandhuman request or agent dispatch
02Scheduledrecurring responsibility with a budget
03Event drivenrepository, webhook, or system change
04Always onwatchers, signals, and background agents
Voxelbox control planeRoutine → task → owner → execution → review → result
dispatchjobsmailthreadsapprovalsevents
Sotto / Vineloghospitality products, research, and operations
Maverickcompany formation, product research, and operations
tmarman.compublishing, projects, and career operations
Voxelboxits own repositories, agents, and infrastructure
Visible outcomeschanges · releases · research · decisions · messagesEvery result returns as evidence for the next run.

Architecture adjacency

Buzz is a natural surface

Block's Buzz gives humans, agents, workflows, and repositories one signed event log and one shared workspace. It already speaks the protocols Voxelbox expects at the edge: ACP for harnesses, MCP for tools, and events for work that happens outside an open chat.

The clean fit is an adapter, not a merger. Buzz can own rooms, membership, approvals, search, and the human conversation. Voxelbox can own agent identity, context, delegation, schedules, and durable execution. A Buzz event creates or updates work; Voxelbox projects progress and results back into the room.

Proposed surface adapterShared workspace outside. Durable execution underneath.
Block / Buzz ↗
Buzz owns

Community surface

  • signed events + identity
  • channels, threads + approvals
  • shared search + audit trail
Surface adapter
message · reaction · schedule · webhook
Buzz event → Voxelbox taskVoxelbox event → Buzz channel
Voxelbox owns

Agent operating layer

  • context + durable memory
  • delegation + harness routing
  • background lifecycle + evidence

Architecture hypothesis, not a current integration. Buzz remains the source of truth for the room; Voxelbox remains the source of truth for delegated work.

Runtime integration

Native sessions become durable context

Claude Code and Codex remain the source of truth for their own transcripts. Voxelbox listens at lifecycle hooks when they exist, then reconciles local session directories on an interval so missed events and imported work still enter the same record.

Before compaction, a hook checkpoints decisions, active files, and open threads. At stop, another extracts intent, tools, files, and commits. The session bridge kicks off a derived summary only after capture; it never replaces or rewrites the underlying transcript.

Native session sources

Claude Code~/.claude/projects/*

Codex~/.codex/sessions/*

Voxelbox harness~/.voxelbox/state/*

Capture seams
ImmediateLifecycle hookssession start · pre-compact · stop
ReconcilePeriodic session syncdiscover · import · update · recover
Normalize
identityworkspaceintenttoolsfilesoutcome

Raw transcripts stay untouched.

Durable outputs

Session recordstatus + lineage

Activity logwork + evidence

Pre-compact factsdecisions + open threads

Memory pagederived summary

Eventually I would like Voxelbox to stop asking me questions it already knows how to answer.
Keep exploring

Other projects

View the full index