Introduction

What is Aether?

Aether is an open-source coding agent harness that gives you control over every token in context. Run it in a TUI, IDE/editor (via ACP), headlessly, or use it as a library.

Terminal

Aether runs in your terminal via a fancy TUI:

aether

IDE/Editor

Aether runs in any IDE or editor that supports ACP:

aether acp

Headless

Aether runs headlessly in a container or VM:

aether headless "Explain the main function in this project"

Library

Rust

Ather agents can be defined and controlled via a Rust crate:

use aether_core::core::{Prompt, agent};
use llm::{ProviderFactory, providers::openai_compatible::generic::{GenericOpenAiProvider, ZAI}};

async fn example() -> Result<(), Box<dyn std::error::Error>> {
    let provider = GenericOpenAiProvider::from_env(&ZAI)?
        .with_model("glm-5.1");

    let (_user_tx, _agent_rx, _handle) = agent(provider)
        .system_prompt(Prompt::text("You are a helpful assistant."))
        .spawn()
        .await?;

    Ok(())
}

TypeScript

Aether agents can be programatically defined and controlled via a TypeScript SDK:

import { AetherSession, type AetherSettings } from "@aether-agent/sdk";

async function example() {
  const settings: AetherSettings = {
    agent: "Example",
    agents: [
      {
        name: "Example",
        description: "A helpful assistant.",
        model: "zai:glm-5.1",
        userInvocable: true,
        prompts: [{ type: "text", text: "You are a helpful assistant." }],
      },
    ],
  };

  await using session = await AetherSession.start({ settings });
}

Why Aether?

There are many coding agent harnesses. So, what makes Aether special?:

Written in Rust

Aether is written in Rust because you deserve a performant agent that isn’t vibe-coded slop built on React + TypeScript.

Modular by design

Some agents are minimal, others are “batteries-included”. Aether is modular; it does both.

Minimal agents are great until you have to “draw the rest of the f-ing owl”. Batteries-included agents are great until you need more control and end up fighting the prompts and tools that were hardcoded into the harness.

Aether gives you the best of both worlds. Your agent starts as a blank slate with no system prompt or tools. Then you add only what you need via 1st-party extentsions for fileystem tools, skills, sub-agents, LSP integration and more. You’re not left to draw the “owl” by yourself.

MCP, done better

Aether agents get tools exclusively via MCP servers . This makes Aether easy to extend in any language you want.

MCP has a bad rap for “wasting tokens” because many MCP clients dump tool definitions directly into context. Aether doesn’t do that. It has token-efficient progessive tool discovery built-in. So you don’t need to worry about MCP vs CLIs.

ACP-1st Architecture

Aether is an ACP-1st agent. This makes it easy to run “anywhere” by attaching it to an ACP client. Aether’s TUI (Wisp) is an ACP client. Aether’s TypeScript SDK is an ACP client…etc.