Project Info
Inspiration
Vibe coding is everywhere, but it's a black box: you fire off a prompt and watch as your codebase is changed in mysterious ways. For beginners especially, there's no mental model of what's actually happening under the hood. With Space Agents!, we wanted to build a tool to make the agentic workflow transparent, visualizing your codebase topology and the swarm of agents operating on it in real time.
What it does
Space Agents! is an orchestration and observability platform for agentic swarms working on your codebase. It renders a project's file tree in real-time, with directories and files as planets and agents as spaceships flying between them. Each agent's activity, target file, and operation type are tracked live. The visualization encodes file metadata (type via color, size via scale) and supports manual pan/zoom for navigating dense clusters. Launch new agents from within the app!
How we built it
We hooked into Claude Code via session hooks to stream agent information to a Rust server, which relays events to the frontend over WebSockets. The frontend uses the Rust notify crate for filesystem watching and the Bevy game engine for real-time 3D rendering of the codebase graph and agent state.
Challenges we ran into
Space Agents! is coded entirely in Bevy, a Rust game engine, which had a steep learning curve for most of the team. We integrated the Claude Code SDK for the first time, and we had a lot of fun designing a clean event pipeline using hook and websocket information to keep rendering modular.
Accomplishments we're proud of
We built a tool that we will use ourselves. We also think our visuals are quite fun, while still being useful to the user!
What's next
Multiplayer mode: Code collaboratively, view your teammates' agent swarms next to your own Agentic interaction directly from the visualization: spawn, control, & kill agents from the app itself Multiple options for customizing the layout depending on user preferences
Space Agents!
A 3D command center for agentic swarms. Renders your codebase as a galaxy and your AI agents as spaceships navigating it in real time.

Built at TreeHacks 2026!
What it does
Space Agents! visualizes a live codebase as a spiral galaxy: files and directories become stars, and each AI agent is a spaceship flying between them. View what every agent is doing (reading, writing, editing), which files are hot, and how your project is structured at a glance. Launch and command agents from the interface.
Files are color-coded by type and scaled by size. Agents are labeled and color-matched for tracking. Hover over any star to see recent activity. Zoom, orbit, or let the camera fly on autopilot.
Architecture
├── frontend/ # Bevy 3D visualization
│ └── src/
│ ├── main.rs # App entry, UI systems
│ ├── agent.rs # Agent tracking & movement
│ ├── galaxy.rs # Star rendering & layout
│ ├── fs_model.rs # File system model
│ ├── watcher.rs # FS watcher (notify crate)
│ └── ws_client.rs # WebSocket client
└── server/ # Event relay server
└── src/
└── main.rs # Ingests agent events, broadcasts via WS
Claude Code hooks stream agent telemetry to the server, which relays it to the frontend over WebSockets. The frontend watches the filesystem directly via the Rust notify crate and renders everything with the Bevy game engine.
Stack
- Frontend: Rust + Bevy
- Server: Rust + warp
- Networking: WebSocket (tungstenite)
- FS watching: notify crate
- Rendering: Custom bloom/glow, bevy_picking, bevy_fontmesh
Getting started
Prerequisites
- Rust 1.75+ (rustup.rs)
Build
git clone <your-repo-url>
cd agent-vis
# build both
cd frontend && cargo build
cd ../server && cargo build
Run
1. Start the server
cd server
cargo run
2. Start the frontend
cd frontend
cargo run -- /path/to/your/project
This will model the file tree, watch for changes, and connect to the server for agent events.
Controls
- Auto mode (default): camera orbits on its own
- Manual mode: arrow keys to rotate/zoom, W/S to adjust height
- Hover over any star to see recent file activity
Development
# server with auto-reload
cd server && cargo watch -x run
# frontend (debug build, faster compiles)
cd frontend && cargo run -- /path/to/project
# verbose logging
RUST_LOG=debug cargo run -- /path/to/project
Analysis
View
Metric
- 22
- 21
- 19
- 13
Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.
Technology
- RustIn code
1 of 1 appear in the indexed code.
AI coding agents
- Claude CodeConfig
Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.
Codebase size
Source size
134 KB
Source files
11
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
ThoseWhoHackTrees/agent-vis
29 files · 6.5 MB · @ f897e75
Structure
API & routing
3 files · 10%Request entry points: routes, handlers and controllers.
Application logic
13 files · 45%Domain rules, services and shared utilities.
Supporting
Layers are inferred from where files sit in the tree, not from reading the code. A project that names its directories unconventionally will read oddly here — open the file browser to check anything the diagram implies.
Languages
- Rust96%
- Markdown2%
- Shell1%
Share of indexed source by file size. Binary and vendored files are excluded.
Dependencies
server/Cargo.toml
cargo · 10- chrono
- clap
- futures-util
- ignore
- rand
- serde
- serde_json
- tokio
- tokio-stream
- warp
frontend/Cargo.toml
cargo · 8- bevy
- bevy_fontmesh
- crossbeam-channel
- ignore
- notify
- serde
- serde_json
- tungstenite
Declared in the repository’s manifests at the indexed commit. A declared package is not proof it is used, and runtime dependencies are listed first.
This project’s features have not been analysed yet.
Export this project's context (description, README, evidence, key source files) to chat with an AI agent elsewhere.