Website | Quickstart Docs

Aether is an AI coding agent harness, written in Rust, that gives you control over every token in context. Aether works with both local and remote LLM providers and runs in your terminal, IDE/Editor, or headlessly.

• Why Aether?
• Quick Start
  • 1. Install
  • 2. Create your first agent
  • 3. Run it
• Using Aether as a library
• Packages
• License

Many harnesses ship with hardcoded system prompts and tools that bloat context and cause you to fight the harness for control.

Aether takes a different approach. Agents begin as blank slates with no system prompt and 0 tools, so every token is yours to mold. Then, you add what you need. Aether is highly modular by design. You can go from a minimal agent to fully batteries-included with just a few lines of config.

• Your Prompt: System prompts are just arrays of markdown files. Edit and compose instructions however you wish. It doesn't matter if you name your files CLAUDE.md, AGENTS.md, or THE_FUTURE.md.
• Your Tools: Aether agents get tools exclusively via MCP servers. Extend capabilities using any language you like. Local and remote servers are supported (including OAuth). And Aether ships with 1st-party MCPs for file system operations, lsp integration, sub-agents, skills and more. Connect as many MCPs as you'd like without blowing out your context window as progressive discovery is built into the harness.
• Your Model: Anthropic, OpenAI, OpenRouter, DeepSeek, Gemini, Moonshot, ZAI, Llama.cpp, and Ollama are supported out of the box. Bring your own provider via the StreamingModelProvider trait, or alloy models together to combine their strengths.
• Your Interface:
  • TUI: Aether's TUI supports syntax highlighting, PR-style comments on git diffs to give feedback to your agent, custom themes and more.
  • IDE/Editor: Aether is an ACP agent, so you can use it with any client that supports ACP (e.g. Zed).
  • Headless: Aether can be run as a headless agent that streams structured JSON logs.
  • Rust library: Aether can also be used as a Rust library to build agentic applications.

macOS (Apple Silicon):

brew install contextbridge/tap/aether

macOS / Linux (x64, ARM64):

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/contextbridge/aether/releases/latest/download/aether-agent-cli-installer.sh | sh

Any platform (requires Rust 1.85+):

cargo install aether-agent-cli

cd your-project
aether agent new

✓ Created .aether/settings.json   — agent definitions (model, prompts, tools)
✓ Created .aether/mcp.json        — MCP server config
✓ Created .aether/SYSTEM.md       — base system prompt
✓ Created AGENTS.md               — project-level instructions

• In a TUI — interactive terminal UI:

  aether

• In an editor/IDE via ACP:

  aether acp

• As a headless agent:

  aether headless "Refactor auth module"

Use aether-agent-core as a Rust library to build your own agent in ~25 lines. Bring your own model via the StreamingModelProvider trait, or alloy models together to round-robin across providers per turn.

1. Add dependencies

   cargo add aether-agent-core tokio

2. Write your agent

   use aether_core::{
       core::{Prompt, agent},
       events::{AgentMessage, UserMessage},
       mcp::{McpSpawnResult, mcp},
   };
   use llm::providers::anthropic::AnthropicProvider;
   use std::io::{self, Write};
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       // 1. Create a provider (reads ANTHROPIC_API_KEY from env)
       let llm = AnthropicProvider::new(None)?;
   
       // 2. Spawn MCP tool servers from one or more mcp.json files
       let McpSpawnResult { tool_definitions: tools, command_tx: mcp_tx, .. } =
           mcp().from_json_files(&["mcp.json"]).await?.spawn().await?;
   
       // 3. Build and spawn the agent
       let (tx, mut rx, _handle) = agent(llm)
           .system_prompt(Prompt::from_globs(vec!["AGENTS.md".into()], ".".into()))
           .tools(mcp_tx, tools)
           .spawn()
           .await?;
   
       // 4. Send a message and stream the response
       tx.send(UserMessage::text("Hello!")).await?;
   
       loop {
           match rx.recv().await {
               Some(AgentMessage::Text { chunk, is_complete, .. }) => {
                   if !is_complete { print!("{chunk}"); io::stdout().flush()?; }
               }
               Some(AgentMessage::Done) => break,
               Some(AgentMessage::Error { message }) => { eprintln!("Error: {message}"); break; }
               _ => {}
           }
       }
       Ok(())
   }

MIT