Aster
A self-hosted terminal coding agent that reads, edits, runs and reviews code on your machine, with your model and your key.
Permission modes (plan/manual/auto/edit/yolo), a sandbox limiting writes to repo+temp with secrets stripped, a rule language (allow/ask/deny, parsed inside bash -lc), and default refusal to read env/key files are well evidenced, so least_privilege and user_confirmation earn full marks; rollback relies implicitly on git with no explicit undo/recovery mechanism — deducted there. Builds use --locked and rustls but no cargo-audit or dependency-scanning evidence is shown, so dependency_security is 2. aster remote (Telegram) and --comment posting have approvals but cannot be verified statically, so external_effects is conservatively 2.
README and code stay consistent (port fallback, log caps, the f64 serialization fix), and desktop error-parsing tests are meticulous, so self_consistency and failure_messages score high. Multiple providers and local-model support lower external-dependency risk, but there is no degradation guarantee for endpoint availability — dependency_availability loses a point.
Four surfaces (terminal/editor/browser/desktop) and Linux/macOS/Windows/Android/musl coverage are explicit, so audience_and_scenarios and environment_fit are strong. But the project is pre-1.0, self-described as having rough edges, and the confidence score is admitted to be non-calibrated, so capability_boundaries and trigger_precision are deducted to 2.
Docs are complete (CONFIG/ARCHITECTURE/ALGORITHM, etc.), install paths are clear, Apache-2.0 ships in full, and examples are rich — license and install_notes full marks. No CHANGELOG exists (only version 0.5.2, policy 'track main'), so versioning_changelog is 1. Maintenance is a solo developer who states in the README they are job hunting, with no sustained-maintenance commitment — maintenance_responsibility is 1.
Output usability is strong (-- everywhere, structured findings consumable by CI) — full marks. The verify/refute pipeline is differentiated value, but its cost model and benefit are self-reported and EVAL.md itself disclaims what the numbers can claim, so marginal_value and cost_benefit are conservatively 2.
Claims link to specific docs and config examples, giving traceability; CI runs fmt+clippy+test on push/PR and desktop TS unit tests are present, but no Rust test files appear in the evidence and most claims are single-source first-party statements. All three criteria are 2: traceable and internally corroborated but not independently verified, and some forward-looking statements (e.g. 'cannot come back') blur fact and expectation.
- The install script is curl|sh; review https://withaster.dev/install before executing it.
- The confidence score is the verifier's self-reported value, not a calibrated probability; do not gate on it alone.
- aster remote can drive the agent from Telegram — verify approvals and deny rules cover dangerous commands before enabling.
- yolo mode has no sandbox and no rules; keep the default edit mode unless you understand the risk.
- The project is pre-1.0, solo-maintained, and the author is publicly job hunting; assess maintenance continuity before production use, and diff releases manually since there is no CHANGELOG.
What does this agent do, and when should you use it?
Aster is an open-source coding agent harness written in Rust that runs in the terminal, with the same agent also reachable through a browser UI (aster serve), a VS Code extension, a Zed extension over the Agent Client Protocol, and a Tauri desktop app. It reads your codebase, answers questions, edits files, runs commands, and reviews changes, working with any OpenAI-compatible provider including OpenRouter, OpenAI, Groq, Anthropic, and local models via Ollama, LM Studio, vLLM, or llama.cpp. Sessions, memory, and skills are plain files on your disk — there is no hosted control plane, no vector database, and no telemetry. Its review capability runs a four-stage pipeline (HYPOTHESIZE, RETRIEVE, VERIFY, SHAPE) where a cheap model over-produces candidate defects and a second call prompted to refute kills plausible-but-wrong findings. The project describes itself as early and building in the open: chat, review, memory, skills, permissions, MCP, and the browser, editor, and desktop surfaces have landed, but rough edges are expected.
Aster reads repository files and retrieves evidence through a local symbol index built on SQLite, FTS5, and ripgrep. In chat, it answers questions about the code, edits files, and runs commands under five permission modes (plan, manual, auto, edit, yolo) plus allow/ask/deny rules; outside yolo, commands run in a sandbox limited to repo and temp directories with secrets stripped from the environment. aster review examines the current branch, an explicit range, a stdin diff, or a GitHub PR and emits findings with severity, category, and confidence as JSON, which aster fix --apply can turn into edits. Other subcommands include aster memory (facts kept between sessions), aster skills (on-demand instructions, importable from Claude Code, Cursor, and other agents), aster plugins (Agent Plugins packages), aster mcp (progressive injection of MCP server tools), aster web (search, fetch, crawl rendered as Markdown), aster remote (driving the agent from Telegram), and aster serve (a loopback browser UI on port 4187 by default). Configuration lives in aster.yaml and environment variables such as ASTER_API_KEY, ASTER_BASE_URL, and ASTER_MODEL; API keys are read from the environment only.
- A solo developer who wants a coding assistant running locally with their own API key or a local model, without code leaving the machine
- A team adding automated review of branches or GitHub PRs before merge, piping JSON findings into CI
- A Zed or VS Code user who wants an agent panel in the editor with streamed replies, diffs, and permission prompts
- A developer who wants review findings automatically turned into fix patches (aster review -- | aster fix --apply)
- A user who wants per-turn model routing via mom.yaml so cheap models handle routine work and hard tasks escalate to a stronger model
- A mobile user issuing tasks and approvals from Telegram via aster remote
What are this agent's strengths and limitations?
- Fully self-owned: keys, model, sessions, and memory are local files with no hosted control plane and no telemetry; pointing at a local model makes it work with no network at all
- Verification-first review: a second model call prompted to refute filters plausible-but-wrong findings, with an adjustable --min-confidence gate
- One harness across surfaces: terminal, browser, VS Code, Zed, and desktop share the same config, sessions, and skills
- Fine-grained permission model: five modes plus allow/ask/deny rules; Bash rules parse inside bash -lc chains, and commands are sandboxed outside yolo
- Rich extensibility: progressive MCP tool injection, Agent Plugins packages, and a skills system that imports from Claude Code, Cursor, and other agents
- Self-described as 'early, building in the open' with expected rough edges — a real maturity risk to absorb
- Building from source requires Rust 1.85 or newer
- Designed around OpenAI-compatible endpoints; native non-OpenAI-compatible protocols would need adaptation
- Review confidence reflects the verifier's self-reported confidence, not a calibrated probability, so treat it as a ranking signal only
- No hosted service: centralized management, auditing, and multi-tenant features for teams are not documented
How do you install or deploy this agent?
One-line install: curl -fsSL https://withaster.dev/install | sh, or build from source (Rust 1.85+): git clone https://github.com/zfinix/aster && cd aster && cargo install --path crates/aster-cli. You need a model endpoint: an API key for any OpenAI-compatible provider, or a local model (Ollama, LM Studio, vLLM, llama.cpp). First run of aster walks you through connecting, writes ~/.aster/aster.yaml, and stores keys in ~/.aster/.env; alternatively export ASTER_API_KEY=sk-..., ASTER_BASE_URL=https://openrouter.ai/api/v1, and ASTER_MODEL=anthropic/claude-sonnet-5.
How do you use this agent?
cd into your repo and run aster to open the chat TUI; use @ to mention files, / for slash commands (/model, /provider, /mode, /effort, /resume, ...), and shift+tab to cycle permission modes. Non-interactive usage: aster chat "why is finding 2 critical?" for a single answer; echo "explain this repo" | aster to pipe a prompt; aster chat --continue or --resume to reopen sessions. Review changes with aster review (current branch), aster review --range main..HEAD, git diff HEAD~1 | aster review --diff -, or aster review --pr 42 (after aster login); add -- for machine-readable output and --comment to post findings as PR comments. Launch the browser UI with aster serve, then open http://localhost:4187.
How does this agent compare with similar options?
The README notes skills can be imported from agents already installed on the machine, naming Claude Code, Cursor, Codex, and Gemini CLI — adjacent terminal coding agents. Aster's differentiation is self-hosting with no telemetry, free model switching, and a built-in verification-first review pipeline.