Who Hypa is for#
Developers running multiple AI coding agents
Hypa keeps each agent in its own pane, lets agents read each other's output, and prevents agents from stepping on the same files by running subtasks in hidden panes. You can attach and detach without losing agent state, which matters on long-running code generation or refactor sessions.
Skip if:
You run only a single coding agent at a time and do not need persistent pane state between terminal sessions. A standard terminal with tmux serves that workflow without the added setup.
Teams with long build and test pipelines
The compression filters for dotnet, cargo, go test, jest, pytest, xcodebuild, and others reduce build log volume before it reaches an agent. A 1200-token build failure can compress to 340 tokens, which extends how many tool calls an agent can run before the context fills.
Skip if:
Your build tool is not in the built-in filter list and you do not want to write a custom DSL filter. The savings in that case are limited to the generic token accounting pass.
Developers who need remote terminal access
`hypa --remote user@host` attaches to a mux running on a remote machine through a standard OpenSSH connection. Hypa adds no credential storage on top of SSH. The share-and-connect feature lets you hand a session to a colleague using a local invite, with QUIC transport and a certificate pin for security.
Skip if:
You need Windows as a server host, or you are on a musl-based Linux system like Alpine. Neither is supported for the mux host role.
The problem it solves#
Coding agents run inside a terminal, but nothing about a standard terminal is designed for agents. A long build log, a verbose test suite, or a failed deploy floods the agent's context window with noise, burning tokens on output that carries no signal. The agent has no way to split work into parallel panes, no way to hand a subtask to a background process, and no way to keep running if you close the terminal and reopen it.
Coordinating more than one agent at a time is worse. Each new agent session starts cold. If you want one agent to wait for another to finish, or to read the output from a pane the first agent is driving, you are doing that coordination manually, outside the tools themselves.
How it solves it#
Terminal workspace mux
Hypa starts a local multiplexer server that owns all your panes. You can attach from any terminal, detach, and reattach without losing running processes. The server holds sessions with workspaces, tabs, splits, a sidebar, copy mode, popups, and 19 built-in themes. Configuration lives in `~/.config/hypa/config.toml` and validates on startup rather than silently falling back.
Agent skill installation
`hypa integration install` detects the AI coding tools on your machine (Claude, Codex, Copilot, Cursor, Grok, and others) and writes a skill file that teaches each one how to read panes, spawn work in a new or hidden pane, wait for a sibling agent, and report its state. The skill is printed via `hypa --skill` and exposed as an MCP server with `hypa serve`.
Output compression
`hypa -c "command"` runs any command, strips the noise, and returns only what an agent needs: errors, warnings, file paths, failing tests, and exit codes. The reduction is deterministic and local: the same input always produces the same compact output. Built-in filters cover dotnet, cargo, gradle, mvn, go test, jest, pytest, xcodebuild, npm, pnpm, yarn, terraform, kubectl, docker, and others. A footer reports token savings, e.g. `[hypa: 1200→340 tok, -72%, reducer=dotnet-build]`.
Session sharing over QUIC
You can share a running session with another machine using an invite that carries every reachable address. The other machine tries each address and uses the one that responds. QUIC is the first path; TCP with TLS is the fallback. Every connection is protected by a certificate pin, so the session secret travels only after the pin matches.
SSH remote attach
`hypa --remote user@host` attaches to a mux running on another machine through a standard OpenSSH connection. Hypa stores no keys or credentials; OpenSSH handles authentication entirely. You get the full local view of a remote session without a separate VPN or proxy.
Strengths and trade-offs#
Strengths
- No cloud dependencyHypa runs a local server and stores all data in `~/.hypa/` as a SQLite database. There is no account to create, no API key to manage, and no required outbound traffic for the workspace or compression features. Teams with data-residency requirements or offline development environments can use it without exception.
- Rule-based output compressionThe compression filter is rule-based. It strips noise predictably: the same build log produces the same compact output every time, using a command-specific reducer rather than LLM inference. You can test any filter against a saved output with `hypa filters test NAME ./output.txt` and measure estimated savings across your filter suite with `hypa filters savings --markdown`.
- Multi-agent coordination from the terminalAn agent can read any other pane, spawn a new pane for a subtask, or send work to a hidden background pane. Agents can wait on each other using the runtime API. Panes keep running after you close the terminal and reattach when you return. This is managed entirely through the local mux, with no external orchestration layer.
- Broad agent tool supportHypa writes skills for every AI coding agent it detects on install. The supported list at 1.0.0 includes Claude, Codex, Copilot, Cursor, Grok, Pi, and others; run `hypa integration install --help` for the current list. The skill exposes the pane API and the compression commands as operations the agent can call.
Trade-offs
- -No Windows mux supportThe workspace mux only runs on Linux (x64 and arm64, glibc 2.34 or newer) and macOS (x64 and arm64, macOS 12 or newer). Windows is not a mux host; there is no Windows mux archive, and the installer stops with an error. The compression CLI can be built from source on Windows using the .NET 10 SDK, but the pane-management and agent-runtime features require Linux or macOS.
- -Functional Source License, not OSI open sourceHypa is licensed under FSL-1.1-ALv2, which allows internal and professional use but forbids offering Hypa's functionality as a competing commercial product or managed service. The source is available and self-hosting is unrestricted, but it is not an OSI-approved open source license. After two years from each release date, the code becomes Apache 2.0.
- -Plugins run without sandboxingA Hypa plugin runs as your user with full permissions. There is no isolation layer between a plugin and your filesystem, credentials, or running processes. The project documents this explicitly; install only plugins from sources you trust.
Hypa vs alternatives#
Hypa vs Warp
Both tools bring AI capability to terminal workflows, but they differ in where computation runs and how agents interact with panes.
| Feature | Hypa | Warp |
|---|---|---|
| License | FSL-1.1-ALv2 (Apache 2.0 after 2 years) | Proprietary |
| Self-hosting | Full local install, no cloud | Cloud-connected AI features |
| Output compression | Deterministic, rule-based, local | Not a built-in feature |
| Multi-agent coordination | Yes, via pane API | No |
| Agent skill installation | Detects and configures installed agents | Warp AI built-in |
| Platform | Linux and macOS | macOS, Linux, Windows |
| Windows mux | Not supported | Yes |
Hypa is the better choice when your primary concern is keeping all processing on your own machine. Its output compression and pane API work entirely offline, and the multi-agent coordination features are unavailable in Warp. Developers who run Claude Code, Codex, or Cursor and want those agents to share pane state, spawn background work, or hand off subtasks to each other need Hypa's mux layer; Warp does not expose that coordination surface.
Warp is the better choice if you want Windows support or prefer a polished GUI terminal experience with AI built in. Warp's AI assistance is mature, its block-based output model makes copying results easy, and it does not require installing a local server. If you work primarily on Windows, Hypa's mux does not run there.
Quick start#
Install Hypa on Linux or macOS via the install script, Homebrew, npm, or pipx.
```bash
# Install script (Linux and macOS)
curl -fsSL https://raw.githubusercontent.com/Hypabolic/Hypa/main/install.sh | sh
# Homebrew
brew install hypabolic/tap/hypa
# npm
npm install --global @hypabolic/hypa
# pipx
pipx install hypa
```What it's built on#
- Languages
- CC#TypeScript
FAQ#
What is the Hypa license, and can I use it commercially?
Hypa is licensed under the Functional Source License 1.1 (FSL-1.1-ALv2). You can use, copy, modify, and redistribute it for any purpose including internal commercial and professional work. The one restriction is using it to offer a competing product or managed service to other customers. Two years after each release date, that version of the code becomes available under the Apache License 2.0.
Does Hypa require a cloud account or internet access?
No. The workspace mux and output compression both run locally. Data is stored in ~/.hypa/ as a SQLite database. There is no account, no API key, and no required outbound connection for the core features.
Which AI coding agents does Hypa support?
Hypa detects agents installed on your machine and writes a skill for each one. Supported agents at 1.0.0 include Claude, Codex, Copilot, Cursor, Grok, Pi, and others. Run hypa integration install --help to see the current list, and hypa integration status to check what is installed.
Does Hypa work on Windows?
The workspace mux does not run on Windows; there is no Windows mux archive. The output compression CLI can be built from source on Windows using the .NET 10 SDK. If you need the full pane-management and agent runtime features, you need Linux or macOS.
How does output compression differ from an AI summary?
The compression is deterministic and rule-based. Hypa runs a command through a command-specific reducer (for example, dotnet-build or pytest), then through any applicable DSL filters, and returns only errors, warnings, file paths, failing tests, and exit codes. The same input always produces the same compact output. You can test filters locally with hypa filters test NAME ./output.txt.
Similar open-source tools#
deja
Predictive ghost-text zsh suggestions with no account or cloud
Omnara
Open-source agent deployment API. Self-host or use Omnara Cloud.
Cloudflare Os
Open source AI workspace with sandboxed apps and Gatekeeper security
Firebase Ios Sdk
Open source Apple SDK for Firebase auth, data, push and crashes
OpenShell
Sandboxed runtime for autonomous AI agents, open source by NVIDIA
ax
Declarative runtime for autonomous agent workloads