ForgeCode

Why it's ranked here

The codebase backs up the terminal agent pitch: over twenty separate crates split cleanly along domain, application, service and infrastructure lines, a contributor guide that mandates public doc comments, table driven tests beside the code they test, and constructor patterns that ban trait objects. Provider wiring already covers OpenAI, Anthropic, AWS Bedrock and Google Cloud, plus a full Model Context Protocol client, so switching backends is a config change, not a rewrite. That combination of engineering discipline and provider breadth is what separates a serious terminal agent from a wrapper script.

What's good

The three-persona split has real teeth: the read-only research agent cannot touch files at all, and the planning agent only ever writes new planning documents, so you can ask for a full architectural investigation without risking an accidental edit. Conversations are treated as first-class objects: they persist, resume, branch into alternate directions, and rename, closer to version control than a chat log. An isolated workspace flag spins up a fresh git worktree and branch for an experiment before any code changes happen, and a separate semantic search index lets you query a codebase by intent rather than by keyword.

Tradeoffs

The fast path only works in ZSH: the shorthand commands depend on intercepting lines that start with a colon before the shell sees them, so bash or fish users are stuck with the slower full command form. The dependency list is large, including its own analytics client and support for four separate cloud auth schemes, which is more surface area than a lighter terminal tool carries. Nothing in the material read confirms which license covers the project, so that has to be checked before adopting it commercially.

How to use it well

This fits an engineer who already lives at the shell prompt and wants one tool for the whole loop: ask the read-only persona to explain a subsystem, hand the planning persona the resulting scope, then let the implementation persona execute once the plan looks right. The isolated experiment flag is the right call before a risky refactor, since it starts the change in its own branch and worktree automatically. It is not built for someone who wants a GUI or an editor-embedded assistant instead of a shell habit, though a companion integration for a popular code editor also ships alongside it.

Observed

Language

Written in Rust as a Cargo workspace split across many internal crates (forge_domain, forge_app, forge_services, forge_infra, forge_api, forge_config, forge_main, and others).

Packaging

Installed by piping a shell script from forgecode.dev through curl; no package-manager install path is documented in the material read.

Interfaces

Three interfaces: an interactive terminal UI, a single-prompt CLI flag, and a shell-integrated shorthand command system.

Agent personas

Ships three built-in agent personas: one that edits files and runs commands, one read-only research agent, and one planning agent restricted to writing plan documents.

Provider support

Provider support spans OpenAI, Anthropic, AWS Bedrock, and Google Cloud, plus a Model Context Protocol client with child-process and streamable-HTTP transports.

Sandbox mode

Includes a sandbox mode that creates an isolated git worktree and branch before a session starts.

Testing

No dedicated test directory among the crates read; the project's own contributor guide instructs that tests live in the same file as the code they test.

Dependencies

Bundles its own analytics client (posthog-rs) as a workspace dependency.

Editor integration

A separate VS Code integration command group ships alongside the terminal tool.

License

No license file was among the files fetched, so the license is not established by the material read.