octet

A fast, native coding agent for your terminal.
Rust core · any-language extensions · hears audio, uses your computer

octet reads code, edits files, runs tests and manages sessions from your terminal. One native Rust process owns the agent loop, sessions, permissions, persistence, the terminal UI and resource limits — no Node, Python or Bun needed for the core.

It runs cloud or local models, keeps resumable sessions, and takes tools as subprocess extensions you can write in any language that speaks JSON-RPC. It can also listen to audio and drive your computer in the same conversation, which is why it exists.

Install

macOS Apple silicon/Intel and GNU/Linux x86-64, no Node.js required. This pins the exact release — recommended for CI and scripted installs. The source is the v0.10.4 release candidate; these commands install the published 0.10.3:

curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/skaft-software/octet/releases/download/v0.10.3/install-octet.sh | sh

Windows (PowerShell) is a preview; its installer is version-matched to the same release:

irm https://github.com/skaft-software/octet/releases/download/v0.10.3/install-octet.ps1 | iex

Also available via cargo install --locked --git https://github.com/skaft-software/octet --tag v0.10.3 --bins octet-coding-agent, and from a source checkout. npm is not a supported path for this release: see installation for which channels are actually published.

Why octet

It hears what it works on. Native audio input, so a model can take a WAV of your sketch, reason about it, and call tools in the same context — no "transcribe first, paste text back" round trip. Works with audio-capable models; audio is not universal across providers.

It's light. Native Rust core: no runtime to boot before your agent starts. Medians from five measured runs of one ledger task, below: 9.5 s to finish and 38.3 MiB peak process-tree memory.

It's yours to extend. Extensions are separate processes speaking JSON-RPC 2.0. Python, TypeScript, Rust, C++, or no SDK at all — each in its own process, with OS-level permissions.

It's honest about compatibility. Pi extensions run through an optional, explicitly experimental adapter. Some work, some don't; the adapter targets Pi's public extension API, not Pi's internals or its CLI.

Benchmarks

One ledger task, one clean VM, one account, GPT-6 Luna at low reasoning, five measured runs per metric after an excluded warmup. Timing and memory are separate passes.

Five runs on one task are a measurement of this workload, not a general speed or quality claim. Reproduce it from the evidence bundle, which carries the task, the binary identity, every attempt, the protocol, the erratum and the checksums. The runners that record these two metrics, and the reporting rules that apply to them, are in Benchmarking octet.

Pi extensions

v0.10.0 was octet's first Pi-compatible release. Pi extension support ships as an optional, separately installable bundle called octet-pi-compat. It is experimental and compatibility is per-extension. Extensions run as their own processes with OS permissions — the adapter does not sandbox them.

octet extension install octet-pi-compat
# then enable it: /extensions, or --enable-extension octet-pi-compat

It needs Node 22.19+ and a matching octet host version. Bundles are pinned to the host (requires_octet), so after updating octet, refresh each bundle you use:

octet extension update <name>

Compatibility concerns Pi's public extension API — not its private internals or its full CLI. The current ledger of what passes is in Pi compatibility.

Extensions in any language

An extension is a process: read JSON requests on stdin, write responses on stdout. Ship it in whatever you like.

# a complete extension, no SDK
$ cat hello/extension.toml
name = "hello"

$ octet --enable-extension hello

Worked examples you can copy: Python, TypeScript, Rust, C++, and a Perl example with no SDK at all — all in the launch article.

Optional first-party integrations: octet-mcp, octet-subagents, octet-codemode, octet-computer-use, octet-web-search. Installing a bundle doesn't enable or trust it.

Reproducibility

Releases are built and signed in CI, and every asset ships a checksum and a Sigstore bundle.

gh release download v0.10.3 --repo skaft-software/octet --pattern OCTET_SHA256SUMS
shasum -a 256 -c OCTET_SHA256SUMS

OCTET_RELEASE_METADATA.json records the exact source commit the artifacts were built from.

Codebase

Build from source with cargo build --release -p octet-coding-agent; the C contributing guide covers the test lanes and profiles.

Documentation

• Installation · Getting started · Basic usage
• Models and providers · Images, audio and PDFs
• Extensions · Extension API 0.4
• Sessions · Settings · Security
• Pi import and restore · Pi compatibility
• Changelog · Releases

The website has the launch write-up, the full benchmark records and the design notes: https://skaft.org/octet/

Status

octet is a hobby project, and it needs your support. It doesn't aim to chase upstream parity — it aims to be the best agent for the people who use it. The gaps get closed by whoever hits them: platforms are unevenly qualified (Windows is preview), Pi extension compatibility is per-extension, and audio depends on the model route.

It is, however, built for humans: signed releases, published checksums, benchmark evidence you can re-run, and an author who is committed to helping people who want to build on it.

How you can help

Code contributions are the most useful thing you can send. The issue tracker is the work queue — there are open bugs with reproductions, and several are already scoped:

• Pick up an open issue and send a PR. Start from good first issue or help wanted; difficulty is labelled (difficulty/cosmetic through difficulty/architectural) so you can pick your size. area/* labels tell you which crate it lands in.
• Help fix Pi extensions. The adapter is open source at extensions/octet-pi-compat — patches that make a real Pi extension work (or work better) are the most valuable contributions this project gets. Open an issue with the failing extension and its session file, then send the diff. Known deviations are documented in Pi compatibility.
• Write an extension if you'd rather not touch the core — they're separate processes, so you can build something useful without learning the whole host. Send it and we'll link it.
• Fix the docs where they confused you. That's usually a real bug, and it's a one-file PR.

And if code isn't your thing:

• Try it on your platform — Linux distros, Windows, Termux, unusual terminals — and file what breaks, with your terminal and shell.
• Run your Pi extensions through the adapter and report results, pass or fail. Every report improves the compatibility ledger.
• Tell us which audio routes actually work with which model and provider. Audio support is per-route and the matrix is incomplete.

Read CONTRIBUTING.md before your first PR — it covers the build, the test lanes and the AI-assisted contribution policy. If you're testing compatibility, say which octet version, which Pi version, and attach the session file if you can.

Credits

octet owes a clear debt to Pi by Mario Zechner — its agent architecture, terminal interaction patterns and extension protocol informed many design choices here. octet is an independent implementation in Rust, not a fork, and not affiliated with or endorsed by Pi. Local is the typeface used across octet's site.

MIT licensed.