Spacebot

Overview

Spacebot is a Rust-based AI agent framework from the Spacedrive team, designed specifically for teams, communities, and multi-user environments.^[1] While most AI agents are built for one person in one conversation, Spacebot handles concurrent interactions across Discord servers, Slack workspaces, and Telegram groups without any user waiting on another.

The core insight: a single-threaded agent breaks the moment two people talk at once. Spacebot's delegation model means it can think about User A's question, execute a task for User B, and respond to User C's small talk — all simultaneously.

Available as a one-click hosted deploy at spacebot.sh or self-hosted as a single Rust binary with no Docker or microservices required.

The Problem It Solves

Most AI agent frameworks run everything in a single session. One LLM thread handles conversation, thinking, tool execution, memory retrieval, and context compaction — all in one loop.^[1]

When the agent is doing work, it can't talk to you. When it's compacting context, it goes dark. When it retrieves memories, raw results pollute the context with noise.

The Spacebot README directly calls out OpenClaw: "OpenClaw does have subagents, but handles them poorly and there's no enforcement to their use. The session is the bottleneck for everything."

Spacebot splits the monolith into specialized processes that only do one thing and delegate everything else.

Five Process Types

1. Channels

The user-facing LLM process — one per conversation (Discord thread, Slack channel, Telegram DM). Has soul, identity, and personality. Talks to the user. Delegates everything else.

A channel does not: execute tasks directly, search memories itself, or do any heavy tool work. It is always responsive — never blocked by work, never frozen by compaction.

2. Branches

A fork of the channel's context that goes off to think. Has the channel's full conversation history — same context, same memories, same understanding. Operates independently. The channel never sees the working, only the conclusion.

Multiple branches run concurrently. First done, first incorporated. Each branch forks from the channel's context at creation time, like a git branch.

3. Workers

Independent processes that do jobs. Get a specific task, a focused system prompt, and task-appropriate tools. No channel context, no soul, no personality.

Fire-and-forget — do a job and return a result (summarization, file operations, one-shot tasks).

Interactive — long-running, accept follow-up input from the channel (coding sessions, multi-step tasks).

Workers come loaded with tools: shell, file, exec, browser (headless Chrome), Brave web search, and OpenCode integration for full coding agent capabilities.

4. The Compactor

Not an LLM process — a programmatic monitor per channel that watches context size and triggers compaction:

Threshold	Action
>80%	Background compaction (summarize oldest 30%)
>85%	Aggressive compaction (summarize oldest 50%)
>95%	Emergency truncation (hard drop, no LLM)

Compaction workers run alongside the channel without blocking it.

5. The Cortex

The agent's inner monologue. The only process that sees across all channels, workers, and branches simultaneously:

• Generates a memory bulletin — periodically refreshed, LLM-curated briefing injected into every conversation
• Supervises running processes (kills hanging workers, cleans up stale branches)
• Maintains the memory graph (decay, pruning, merging near-duplicates)
• Detects patterns across conversations and creates observations

Memory System

Not markdown files. Not unstructured blocks in a vector database. Spacebot's memory is a typed, graph-connected knowledge system.^[1]

Eight memory types:

• Fact, Preference, Decision, Identity, Event, Observation, Goal, Todo

Five graph edge types:

• RelatedTo, Updates, Contradicts, CausedBy, PartOf

Hybrid recall:

• Vector similarity + full-text search merged via Reciprocal Rank Fusion

Memory import:

• Drop files into ingest/ folder for automatic extraction
• Supports text, markdown, and PDF
• Migrating from OpenClaw? Drop your markdown memory files in and walk away

The agent doesn't just "remember things" — it knows the difference between a fact it learned, a decision that was made, a goal it's working toward, and a preference the user expressed.

Messaging Adapters

Native adapters for Discord, Slack, Telegram, Twitch, and Webchat with full platform feature support:

• Message coalescing — rapid-fire messages batched into a single LLM turn so the agent reads the room instead of spamming replies
• File attachments — send and receive files, images, documents
• Rich messages — embeds, buttons, select menus, polls (Discord); Block Kit and slash commands (Slack)
• Threading — automatic thread creation for long conversations
• Typing indicators — visual feedback while thinking
• Per-channel permissions — guild, channel, and DM-level access control, hot-reloadable

Multi-Agent Support

Each agent is an independent entity with its own:

• Workspace and databases
• Identity files and personality
• Cortex and memory graph
• Messaging bindings

All agents share one binary, one tokio runtime, and one set of API keys. Run a friendly community bot on Discord, a no-nonsense dev assistant on Slack, and a research agent handling background tasks — each with its own identity.

Model Routing

Four-level routing system that picks the right model for every LLM call:

1. Process-type defaults — channels get conversational models, workers get fast/cheap models
2. Task-type overrides — coding workers upgrade to stronger models
3. Prompt complexity scoring — lightweight scorer classifies user messages and routes to cheapest capable model
4. Fallback chains — automatic failover when primary models fail

Supports Anthropic, OpenAI, OpenRouter, Groq, Together, Fireworks, DeepSeek, xAI, Mistral, NVIDIA, MiniMax, Moonshot AI, Z.ai, and Ollama for local models.

Tech Stack

Layer	Technology
Language	Rust (edition 2024)
Async runtime	Tokio
LLM framework	Rig v0.30
Relational data	SQLite (sqlx)
Vector + FTS	LanceDB (HNSW + Tantivy)
Key-value	redb
Embeddings	FastEmbed (local)
Crypto	AES-256-GCM
Discord	Serenity
Slack	slack-morphism
Telegram	teloxide
Browser	Chromiumoxide

Single binary. No Docker required. No server dependencies. All data lives in embedded databases.

Spacedrive Integration

Spacebot is designed as the AI counterpart to Spacedrive — an open source cross-platform file manager built on a virtual distributed filesystem.^[2]

The vision: Spacedrive indexes files across all your devices, clouds, and platforms with content-addressed identity and semantic search. Spacebot brings autonomous reasoning, memory, and task execution. Together, an agent that can think, remember, and act — backed by terabytes of queryable data across every device you own.

Both projects are independent and fully functional on their own, but complementary by design.

Installation

Hosted (easiest):

spacebot.sh → Connect platforms, configure agent, done

Self-hosted:

git clone https://github.com/spacedriveapp/spacebot
cd spacebot
cargo build --release
spacebot  # start as background daemon

Minimal config.toml:

[llm]
openrouter_key = "env:OPENROUTER_API_KEY"

[defaults.routing]
channel = "anthropic/claude-sonnet-4"
worker = "anthropic/claude-sonnet-4"

[[agents]]
id = "my-agent"

[messaging.discord]
token = "env:DISCORD_BOT_TOKEN"

[[bindings]]
agent_id = "my-agent"
channel = "discord"
guild_id = "your-guild-id"

Strengths

• Concurrent by design — 50+ users interact simultaneously without blocking
• Typed memory graph — structure beats unstructured retrieval
• Single binary — no Docker, no microservices, no runtime dependencies
• Team-first — built for communities, not just solo users
• Message coalescing — handles busy channels without spam
• Spacedrive synergy — potential for deep filesystem integration
• Rust performance — no GC pauses, predictable resources

Weaknesses / Considerations

• FSL license — not fully open source until 2 years pass (then Apache 2.0)
• Complexity — 5 process types is more to understand than simpler alternatives
• Rust requirement — self-hosting requires Rust 1.85+ and cargo build
• Newer project — less battle-tested than established frameworks
• Spacedrive dependency — full vision requires both projects

Who Built It

The Spacedrive team, led by Jamie Pine. Spacedrive itself has 35K+ GitHub stars as an open source cross-platform file manager. Spacebot extends their vision into AI agent territory, leveraging the same Rust expertise and distributed systems thinking.

Ideal User

• Community managers running Discord servers with active members
• Teams needing a shared AI assistant across Slack channels
• Rust developers who want a single-binary, no-Docker deployment
• Multi-agent experimenters wanting isolated agents with shared infrastructure
• Spacedrive users looking for AI integration with their file system

Bottom Line

Spacebot represents a serious architectural rethinking of AI agents for multi-user environments. The five-process-type model (Channel, Branch, Worker, Compactor, Cortex) directly addresses the "session bottleneck" problem where most agents go dark during heavy work.

The typed memory graph with 8 memory kinds and 5 edge types is more sophisticated than the markdown-file approach of most alternatives. Combined with hybrid vector+FTS search and LLM-curated memory bulletins, it's one of the more thoughtful memory implementations available.

The FSL license means it's not fully open source yet — a consideration for some teams — but converts to Apache 2.0 after two years. The Spacedrive team's track record (35K+ stars on their file manager) suggests this isn't vaporware.

For teams and communities tired of single-user AI assistants that crumble under concurrent load, Spacebot is the most purpose-built option available.

---