Spacebot's channel has no shell, so the wait happens in a worker
An AI agent for teams, communities, and multi-user environments.
At a glance
- What is it?
- Spacebot is a Rust agent harness that keeps shell, filesystem and memory tools out of the user-facing channel, so thinking and execution run in forked processes. The compaction modes, the twenty weeks between the newest tag and the newest commit, and the four-toolchain build are where the design gets interesting.
- Who is it for?
- Spacebot is a harness for the case where an agent serves several people at once, and its central decision, stripping tools out of the channel, is enforced by the tool layer rather than by a prompt. Adopt it if you can run the instance yourself with your own model keys and a local directory of embedded state.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 51 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- spacedriveapp/spacebot2,436 β Β· +40
| Repository | 2026-09-12 | 2026-11-15 |
|---|---|---|
| spacedriveapp/spacebot | 2.4k | 2.4k |
40 Stars in the last 64 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
A channel with no shell, no filesystem, no memory search
The load-bearing claim in Spacebot is that a conversation process should not be able to block, and the enforcement is mechanical rather than a matter of prompting. A channel is the user-facing LLM process: one per conversation, carrying soul, identity and personality. Its tool list is deliberately short. No shell, no filesystem, no memory search. What it can do is reply, branch, spawn workers, and route.
Because the channel holds nothing that can take time, it stays free to take the next message while the last one is still running. The same arrangement is credited with keeping the channel from going dark to compact, and with keeping compaction notices, skill edits and tool chatter out of the conversation, both of which the project lists as faults of single-threaded harnesses.
Delegation is not something the model chooses. Spacebot describes it as enforced by which tools each process type has, so a channel that decided mid-turn to search the web or open a file has no way to do it. Three channel kinds run as that identical process: a user channel wakes when a person sends a message, a cron channel wakes on a schedule, and the autonomy channel wakes on a typed event such as an approval, a webhook, or an idle condition. Nothing in the overview gives the autonomy channel a different tool set or a narrower identity, so an approval arriving by webhook enters the same conversation with the permissions a human would have had.
User sends message
β Channel receives it
β Branches to think (has channel's context)
β Branch recalls memories, decides what to do
β Branch might spawn a worker for heavy tasks
β Branch returns conclusion
β Branch deleted
β Channel responds to user
Channel context hits 80%
β Compactor notices
β Spins off a compaction worker
β Worker summarizes the oldest span
β Summary swaps in (rolling) or a checkpoint is cut (chronicle)
β Channel never interruptedThat diagram is the whole scheduling contract: a branch is created with the channel's context, recalls memories, may spawn a worker for heavy tasks, returns a conclusion, and is deleted before the channel answers. Nothing in it bounds how many branches may exist at once.
Rolling mode rewrites the one summary the project complains about
Compaction is where Spacebot both fixes and reproduces the fault it opens with. The problem list faults single-threaded harnesses for going dark to compact and for blurring detail each time the context is rewritten under pressure. The answer here is a programmatic monitor rather than a model: it watches context size per channel and spawns a compaction worker before the channel fills up, and the diagram puts the trigger at 80% of context. The supervisor underneath all of this is deliberately kept out of the token budget, handling hung workers, stale branches, timeout policy and memory-graph maintenance with no work and no LLM calls.
Which kind of compaction runs is a configuration choice, `compaction.mode`, with two values. `rolling` keeps one summary at the head of history and rewrites it under pressure. `chronicle` cuts durable checkpoints instead, aimed at sessions that run for weeks.
Rolling is the mode that recreates the stated fault. A single summary rewritten whenever the oldest span is compressed is the same lossy operation the project lists against other harnesses; what changes is only that it happens in a worker rather than in the visible conversation. Chronicle mode does not share that property, since checkpoints accumulate instead of replacing each other, and the same text credits chronicles with keeping a worker's inherited history bounded as sessions age.
Two gaps matter before picking a mode. The 80% trigger appears in the diagram only, with no configuration key named for it in the visible text. And nothing states what a rolling summary drops at a given compression ratio, or whether the two modes can be set per channel or only globally.
A worker begins as a full fork of the channel that delegated to it
A worker is not handed a task description. It begins as a full fork of the channel that delegated to it, so it carries the conversation context behind the task rather than one summary line, and the stated reason is that the worker then acts on intent instead of guessing at it. Workers are independent processes, which is what makes the two delivery styles possible: fire-and-forget for one-shot tasks, or interactive for longer sessions where a follow-up routes to the active worker.
Branches sit one level up and are lighter. A branch forks the channel's context to think, holds the full conversation history, and several run concurrently. Branches recall memories, weigh options, and hand back a conclusion. Keeping raw search results from ever touching the channel is the point of that indirection, and the branch is deleted once it has answered.
The consequence is that inherited context, not the prompt, is the unit of work. Every branch carries the whole history, every worker carries it again, and the only documented mechanism for bounding that growth is compaction. For a channel with a long history, one request to think about something costs a full copy of that history, paid a second time by any worker it spawns.
Nothing in the overview says how many branches a channel may hold at once, whether fan-out is capped, or what happens when two branches reach opposite conclusions and both write back to the same task.
The newest tag is four months older than the newest commit
The version story is tidy in one respect and open in another. The manifest declares the package, the version and the entry point in four lines, and the newest tag matches the version in it, so there is no package-versus-tag drift to catch here.
[package]
name = "spacebot"
version = "0.5.0"
edition = "2024"
default-run = "spacebot"The dates are the interesting part. v0.4.0 and v0.4.1 shipped two days apart, on 2026-04-02 and 2026-04-04, then v0.5.0 on 2026-05-07. The last commit to the repository is dated 2026-09-25. That leaves roughly twenty weeks of work on main that no tag names, so anyone pinning to v0.5.0 in October is pinning to a May tree, and anyone tracking main is running code whose release notes do not exist. The repository root carries a CHANGELOG.md, which is where that window should be accounted for.
Read as cadence rather than as a verdict, three tags inside five weeks in spring and nothing since May says more about how this project ships than any adjective would.
One binary, five apt packages and two JavaScript runtimes
The claim that Spacebot ships as one Rust binary is true of the artifact and quiet about the toolchain. The Dockerfile builds on rust:bookworm, then installs protobuf-compiler, libprotobuf-dev, cmake, libssl-dev and pkg-config, with comments tying cmake to onig_sys and lz4-sys and libssl-dev to openssl-sys for reqwest's TLS. Bun is installed by piping a remote script straight into a shell, and Node 22 arrives from the NodeSource setup script because the OpenCode embed Vite build needs it. Counting what has to be fetched before a single crate compiles gives five apt packages and two JavaScript runtimes, one of them installed without a pinned version.
Two details in the build order are easy to miss. The image copies vendor/ in beside the manifest and compiles stub binaries first, so cargo fetch has a valid target to work against and the dependency layer caches; the stub src directory is deleted immediately afterward. And the OpenCode embed bundle is built in its own step before the frontend, because the generated assets under interface/public/opencode-embed/ have to exist when Vite runs or they never reach the output.
COPY interface/package.json interface/
RUN cd interface && bun install
COPY scripts/build-opencode-embed.sh scripts/
COPY interface/opencode-embed-src/ interface/opencode-embed-src/
RUN ./scripts/build-opencode-embed.sh
COPY interface/ interface/
RUN cd interface && bun run buildCross compilation is handled by files other than the main Dockerfile: Cross.toml and Dockerfile.cross-aarch64 sit at the root next to it.
Three embedded stores, and a secrets block nobody explains
Local-first is a specific claim here, and the dependency list is where it gets carried out. All state lives in embedded databases inside a directory the operator owns, and three crates cover three different jobs: sqlx with its sqlite and migrate features for relational data, LanceDB at 0.26 with lance-index for the vector side, and redb at 2.4 as a plain embedded store. Embeddings come from fastembed, which runs in process, so the memory graph needs no separate service either. A migrations/ directory at the root means the schema is versioned rather than created on first boot.
rig = { version = "0.33", package = "rig-core", features = ["derive"] }
sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite", "migrate", "chrono", "uuid"] }
lancedb = "0.26"
lance-index = "2.0"
redb = "2.4"
fastembed = "4"
cron = "0.12"
aes-gcm = "0.10"
argon2 = "0.5"The group commented for secrets is the part with the least explanation. aes-gcm is authenticated encryption, sha2 is hashing, argon2 is password hashing, and rand is randomness, all under one comment. Nothing in the overview says where the passphrase comes from, whether the key is derived once at startup or per record, or whether rotating it means re-encrypting existing state. A .envrc file at the root is the usual marker for direnv-based configuration, so the value is plausibly held in a local env file, but the overview does not confirm where it is kept. On a shared host, that question matters more than the model layer does.
The frontend build expects the SpaceUI repo cloned next door
Working on the frontend has a prerequisite the layout does not advertise: five @spacedrive/* packages are developed in a different repository. The spaceui-link recipe refuses to run unless ../spaceui exists and prints the clone command when it does not, then builds and links primitives, ai, forms, explorer and tokens before linking them into interface/. The matching spaceui-unlink recipe reverses all of that and reinstalls from npm, which tells you the ordinary build falls back to published package versions whenever the sibling clone is missing.
That is a sensible arrangement for a monorepo-adjacent setup and a real cost for anyone evaluating the project from a fresh clone. The same file also defines the development entry point, the review gate and type generation:
dev *args:
cargo run -- start {{args}}
preflight:
./scripts/preflight.sh
preflight-ci:
./scripts/preflight.sh --ciTwo details stand out. gate-pr depends on preflight, so that script is a hard gate on any change, and typegen writes the generated spec to /tmp/spacebot-openapi.json but then hands the directory /tmp to openapi-typescript rather than the file path. The rest is ordinary Rust hygiene: fmt-check, check-all, clippy-all, test-lib, and test-integration-compile, which compiles the integration tests without running them.
Metrics exist in the tree and never in the overview
Observability is present in the repository and absent from the write-up. The root carries METRICS.md and examples/prometheus.yml, the dependency list has a full OpenTelemetry 0.31 stack wired through tracing-opentelemetry, and the container build compiles with the metrics feature turned on. The overview mentions none of it, so how those metrics are exposed, whether an endpoint is enabled by default, and what METRICS.md says are all open questions.
Deployment surfaces are wider than the documented path too. The README leads with a hosted one-click deploy at spacebot.sh that connects Discord, Slack, Telegram or Twitch and needs no self-hosting. Underneath it the root holds fly.toml and fly.staging.toml, docker-entrypoint.sh, a nix/ directory with flake.nix and flake.lock, and rust-toolchain.toml, which together cover a Nix-built, Fly-deployed or container-run instance.
The clearest sign of the overview running out is the section headed Workers run other agents. It opens by saying Spacebot is not a coding agent and is the layer above one, holding the goal and breaking it, then stops mid-sentence. The only other trace of that mechanism is a comment in the Dockerfile: the OpenCode embed bundle is the live coding UI in the Workers tab. What a worker actually runs, with which model and under which permissions is not written down, and the architecture page the overview points to is where process capabilities and tool access by type are supposed to live.
Editorial conclusion
Spacebot is a harness for the case where an agent serves several people at once, and its central decision, stripping tools out of the channel, is enforced by the tool layer rather than by a prompt. Adopt it if you can run the instance yourself with your own model keys and a local directory of embedded state. Before pinning a version, check three things: the newest tag is dated 2026-05-07 while the last commit is dated 2026-09-25, `compaction.mode` decides whether old detail gets rewritten or checkpointed, and the secret that aes-gcm and argon2 exist to protect has no documented home in the overview. The LICENSE file at the root and the NOASSERTION license field need resolving too.
Frequently asked questions
What can a Spacebot channel actually do?
A channel is the user-facing LLM process, and the project gives it no shell, no filesystem and no memory search. It can reply, branch, spawn workers and route messages, while the work itself runs in separate worker processes.
Does Spacebot include model access, or do I bring my own keys?
Your own keys. The project describes itself as local-first, with all state in embedded databases in a directory you own. The dependency list points at rig-core for the LLM layer and reqwest for provider calls, so provider choice is configuration rather than a bundled account.
How do I run it from source instead of using the hosted deploy?
The justfile has a dev recipe that runs the daemon through cargo, with extra arguments passed through, so just dev --foreground is the given example. Recipes also cover preflight, fmt-check, clippy-all and test-lib, and gate-pr depends on preflight.
What license is Spacebot released under?
A LICENSE file sits at the root of the repository, yet the license field is NOASSERTION and the overview names no license anywhere. Anyone planning to build on this has to read that file first and settle the mismatch.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/spacedriveapp-spacebot)Star history chart for your README
[](https://hysenlabs.com/projects/spacedriveapp-spacebot)Was this useful?