Where humans and agents work together.
One workspace. Same terminal, same filesystem, same context. Multi-provider AI orchestration that treats collaboration as the primitive, not the feature.
The best collaboration doesn't need a handoff — it happens in the same room.
Most AI tools create a boundary: humans work here, agents work there, and something translates between them. Based removes the boundary entirely.
Humans and agents share the same terminal sessions, navigate the same filesystem, query the same 12 structured domains, and communicate through the same messaging primitives. There's no integration layer because there's nothing to integrate — it's one workspace.
Projects discover themselves through convention. Infrastructure declares itself in YAML. Sessions capture themselves automatically. Memory compounds across conversations. The workspace is the interface.
When you work in Based, you're not managing AI — you're working with it. Same context, same tools, same room.
Real PTY sessions where humans type commands and agents send keystrokes into the same tmux pane. Broadcast mode syncs input across all sessions. No simulator, no sandbox — the real terminal.
Convention-driven project discovery. Drop a manifest in any directory and it exists. Both humans and agents navigate the same tree, edit the same files, read the same configs.
Agents read one manifest and discover every domain, field, filter, and query pattern at runtime. No documentation needed, no custom adapters. Also available as 20+ native MCP tools.
19-mode dashboard with file explorer, session browser, infrastructure map, terminal grid, notes, memory, logs, usage analytics, and kanban. Keyboard-driven. Everything agents see, you see.
Queue the tracks that put you in the zone. Not a streaming service — a focus tool. Three songs on repeat for six hours. You know the ones. Built into the workspace because deep work isn't just code — it's state of mind.
Box — async file drops into any project's inbox. Markdown, images, links, whatever. Drag and drop from the web, or base box from the CLI.
Msg — structured mailbox with sequence numbers and acknowledgments. Agents coordinate through typed messages. Humans read the same inbox.
Beam — real-time tmux send-keys. Broadcast a command to every running session, or target one. Instant. No queue, no delay.
base start launches a tmux session with your chosen AI provider — Claude, Codex, Gemini, or a local Ollama model. Sessions persist. Context carries over. Memory loads automatically.
Multiple sessions run in parallel across different projects and providers. base status shows everything at a glance. base beam sends commands to any session from anywhere.
Every session is captured — messages, tools, tokens, duration. Full transcripts queryable through the API. Agents pick up where they left off, even across provider switches.
Health-checked provider chain with automatic fallback. First healthy provider wins. Switch per-session or let Based route.
intelligence.yaml → priority chain → health check → auto-fallback
base start <name>Launch or resume a tmux session with provider selection
base statusCross-project dashboard — sessions, health, activity
base beam <msg>Send keystrokes to any running session in real time
base boxFile-drop inbox — async messaging between humans and agents
base msgStructured mailbox with sequencing and acknowledgment
base listAll registered projects with type, realm, and status
base new <name>Scaffold a new base with manifest and structure
base memoryExtract and consolidate session knowledge
base swarmOrchestrator plan and task control
base doctorHealth checks, dependency validation, diagnostics
base playFlow state audio — queue tracks, loop, focus
base flagsView and toggle feature flags
base selftestEnd-to-end integration test suite
Coordinator breaks work into tasks
Workers receive via mailbox
Workers use role-scoped tools
Results checked against plan
Coordinators only get orchestration tools — planning, delegation, messaging. Workers only get execution tools — files, search, git, terminal. Clean separation enforced at the MCP level.
File-backed messaging with sequence numbers and acknowledgment. No HTTP between agents, no shared state. Just JSON lines in a mailbox. Simple, inspectable, debuggable.
Auditor, tester, bug-fixer, reviewer, frontend-dev, backend-dev, CLI-dev, docs-writer. Each has skills, commands, and hooks. Mix and match for any workflow.
Every session generates knowledge. Based extracts it — decisions, gotchas, architectural choices, debugging insights — and files it into topic-scoped memory that loads automatically on the next session start.
Memory isn't locked to one agent or one provider. Switch from Claude to Codex, the memory carries over. Onboard a new agent, it reads the same files. The project remembers, not the model.
Auto-dream mode synthesizes insights during quiet hours. The workspace reflects on itself.
Run Opus and Codex side by side on the same project. One reasons deeply about architecture. The other executes fast, parallel file changes. They communicate through Based's messaging primitives — mailbox, file drops, shared memory — and naturally start routing work to whoever handles it better.
This isn't a pipeline or a chain. It's co-work — two agents with different minds reading the same codebase, seeing each other's changes in real time, and developing their own communication patterns to lean into their respective strengths.
No special API. No pairing protocol. Just the workspace primitives that already exist for human-agent collaboration — applied to agent-agent collaboration.
< 640px — phones
Single-pane, bottom tab bar, sheets for secondary content. Check status, read agent updates, send messages, capture notes. Desktop-only features show a placeholder — not a broken miniature.
640–1024px — iPads, small laptops
Narrow icon rail + content pane. Slide-over panels replace persistent sidebars. Files and terminal available with touch-aware controls. Right sidebar becomes a sheet, not a crammed column.
1024px+ — laptops, ultrawides
Full IDE-like 5-column layout. Activity bar, dual sidebars, content area, terminal panel. Ultrawide gets intentional use of extra space instead of stretched emptiness.
Each shell is a separate component consuming the same Zustand store. When you rotate an iPad from landscape to portrait, the shell swaps — your route, your state, your selected project all survive. Monaco and xterm don't even download on phones. That's not a bug, it's a 3MB bundle win.
44px minimum tap targets on touch devices. Pointer modality is a first-class axis — an iPad with a trackpad gets desktop density but touch-safe hit areas. Safe-area insets, dynamic viewport units, sheets over modals. The details that make mobile feel native, not adapted.
JetBrains Mono — doing
Headlines, commands, structure. Monospace fonts create desirable difficulty — the brain works harder to process them, encoding content deeper into memory. Every section title sticks because it costs a little more to read.
Diemand-Yauman et al., 2011 — disfluent fonts improve recall by 14%
IBM Plex Serif — thinking
Philosophy, descriptions, long-form. Serif fonts increase time spent reading and improve recall over sans-serif. The reflective text on this site uses serif because those are the ideas we want you to sit with.
Gasser et al., 2005 — serif fonts aid recall vs. sans-serif
Inter — navigating
Body copy, UI chrome, card text. Sans-serif fonts are fastest to read on screen — they reduce cognitive load on content that should be transparent. Navigation-level text should inform, not compete for attention.
Kaspar et al., 2015 — sans-serif increases online reading speed
Most tools pick one font and call it a day. Based uses typography as a cognitive layer — monospace for structural memory, serif for reflective depth, sans-serif for speed. The same research applies inside the product: terminal sessions use monospace for retention, wiki pages use serif for comprehension, and UI controls use sans-serif to stay out of your way. Your reading environment is part of the tool.
Success, warning, error, info — mapped to meaning, not arbitrary hex values. Change the accent and every status badge, terminal highlight, and diff gutter updates in sync.
Set one background and Based derives the full surface stack — elevated cards, inset panels, borders, hovers. Perceptually uniform spacing so dark themes don't crush detail.
Bring your syntax theme. One Dark, Dracula, Catppuccin, Nord, Solarized — or define your own token map. Applied to Monaco, terminal, and markdown preview simultaneously.
Drop a theme.yaml in any project. The UI shifts when you switch projects. Opus work in purple, Codex work in cyan — color becomes context.
Schedule theme shifts. Cool blue during deep work hours, warm amber at night, full daylight when the sun's up. Your workspace follows your circadian rhythm, not a toggle switch.
Each agent gets a color. When an agent is speaking in the terminal, editing a file, or pushing a status update — its accent color tags the output. You know who did what at a glance.
Based doesn't wrap, proxy, or intercept any AI provider's API. When you start a session, you're running Claude Code, Codex, or Gemini CLI directly in a terminal — exactly as the provider intended. Based just orchestrates the workspace around them.
No third-party API access. No token proxying. No subscription workarounds. Providers see normal CLI usage because it is normal CLI usage.
When providers change their policies, access tiers, or pricing — Based keeps working. It doesn't depend on anything that can be revoked.
Switch providers per-session. Run Claude on one project, Codex on another, local Ollama on a third. Your workspace doesn't care which model is thinking.
Based orchestrates your AI CLIs — it doesn't replace them.
Install your providers separately: claude, codex, gemini, or ollama.
Drop a base.md manifest in any project directory. Add hosts to hosts.yaml. Based discovers them automatically. The filesystem is the database.
Git repos, sessions, memory files, artifacts, configs, health checks — scanned, parsed, and structured into 12 queryable domains accessible from CLI, API, MCP, and web.
Start a session. The agent has full context. Send it a message. Read its memory. Query across everything. Same workspace, same tools, same room.