Code Assistant
A Rust coding agent that reads, edits, and runs projects through desktop, terminal, editor, and MCP interfaces.
Per-dimension scores and reasoning
The evidence shows permission tiers, a command sandbox, filtering of unsafe tool combinations, visibility into tool calls and returned context, and a human handoff for browser login; the release workflow also confines write permission to the final publish job. Deductions apply because tighter sandboxing remains on the roadmap, while per-operation confirmation rules, API-key storage, and log redaction are not documented. Locked Cargo builds and commit-pinned actions and major Git dependencies are positive, but two patched dependencies track branches and no vulnerability scanning or update policy is shown. Session branching offers a recovery primitive, yet no explicit rollback mechanism for agent file edits is documented. The MIT notice attributes an author, but publisher identity and ongoing stewardship remain unverified.
The README, workspace layout, and CI describe a broadly coherent cross-platform, multi-interface product. CI tests GPUI on Linux, macOS, and Windows and runs formatting, linting, and tests on the rest of the workspace, with similar gates before release. Lockfiles and several exact revisions support dependency availability, although branch-based Git patches and the large cross-platform dependency surface prevent full credit. Failure handling has only scattered evidence: release scripts reject downgrades and unknown targets, while the roadmap says helpful stale-file rejection and cleaner failed-tool handling are still unfinished.
Audiences and scenarios are thoroughly identified across GUI, terminal, MCP, ACP, editor, and headless use, with many model providers and support for code plus office documents. Settings and JSON configuration, prebuilt downloads, source builds, and platform-specific guidance provide strong environment fit. Permission tiers, sandboxing, read-before-edit filtering, and login handoff establish some capability boundaries, but no comprehensive boundary matrix is supplied. Tool syntax adapts by session and project guidance can auto-load, yet precise selection rules for tools, skills, and sub-agents are not explained.
The README has clear sections for onboarding, differentiators, features, interfaces, configuration, contribution, and roadmap, with links to focused documentation. Installation covers binaries, platform prerequisites, source builds, and integration examples. Product and command names appear consistent, though compatibility guarantees across four modes and multiple configuration paths are absent. Examples are useful but there is no FAQ. The roadmap discloses meaningful gaps but is not a systematic limitations section. The MIT license is complete. Release automation validates versions, tags and publishes artifacts, and advances the development version, but no changelog is present in the supplied evidence. Contribution guidance and a copyright holder are visible, while formal maintainers, support expectations, security reporting ownership, and response commitments are unspecified.
Visible tool activity, persistent branched sessions, streaming, attachments, formatter reconciliation, and preservation of encoding and line endings support usable work on real repositories. Full credit is withheld because no representative agent output or output-quality acceptance process is included. The autonomous multi-interface loop, document ingestion, browser control, and formatter-aware editing provide substantial marginal value beyond a basic chat interface. Prebuilt packages and GUI configuration reduce setup cost, but model usage, browser automation, external MCP services, and a large Rust build introduce unquantified token, time, and security costs.
Core claims are traceable to specific README descriptions, with the Cargo workspace and CI/release files partially corroborating architecture, platform, dependency, and release claims. The supplied material omits implementation code, linked guide contents, and test results, so important claims about permissions, sandboxing, credential isolation, and encoding preservation cannot be strongly cross-checked. Existing features and roadmap items are generally separated, but categorical claims such as never silently rewriting line endings or never seeing login credentials lack qualifications and implementation evidence, preventing full credit.
- The agent can read and modify files and run commands; verify default permission tiers, sandbox boundaries, command-confirmation behavior, and a recoverable version-control workflow before using it on important repositories.
- API keys may be supplied through settings or environment variables, but the provided material does not explain local storage, log redaction, session recording, or secret handling in attachments.
- MCP client and browser capabilities broaden data flows and external effects; review each connected server, tool permission, network destination, and login-handoff behavior.
- Some Git dependencies follow branches rather than immutable revisions, and no dependency vulnerability scan is shown; inspect the resolved lockfile and dependency security before production adoption.
- The release workflow can delete and recreate an existing version tag and release; maintainers should verify that this matches their artifact-immutability and supply-chain audit requirements.
What does this agent do, and when should you use it?
Code Assistant is an open-source autonomous coding agent written in Rust that operates on local codebases by reading, searching, editing files, and running commands. It ships as a native GUI built with Zed's GPUI, a terminal interface, a headless MCP server, and an ACP agent for editors such as Zed. Users can select providers including Anthropic, OpenAI, Google Vertex AI, Ollama, OpenRouter, SAP AI Core, Groq, Cerebras, and Mistral. Its interface exposes tool executions and the results supplied to the model, while project sessions support branching, persistent state, attachments, sub-agents, permission tiers, command sandboxing, and context compaction. It can also convert Word, Excel, PowerPoint, PDF, and other documents to Markdown and operate a real browser for web-app testing with human-controlled login handoff. The MIT-licensed application runs locally from prebuilt packages or a source build.
After a user adds a project folder and submits a task, Code Assistant runs an autonomous loop that reads and searches files, edits their contents, executes commands, and reports the tool results passed back to the model. When project formatting changes a saved file, it runs the formatter and reconciles the model's edit with the formatted result instead of spending tokens on another read; file writes preserve the original encoding, BOM, and CRLF or LF line endings. It also consumes Word, Excel, PowerPoint, PDF, and other documents as Markdown, connects to external MCP servers, and controls browser sessions for navigation, reading, clicking, and typing. The executable starts its native GUI with code-assistant, its terminal interface with code-assistant --tui, its editor-facing ACP mode with code-assistant acp, and its headless MCP server with code-assistant server. Any mode can receive an initial request through --task, as in code-assistant --task "Explain this codebase".
- A developer who wants autonomous changes to a local repository can use the GUI to inspect each file operation, command, and returned context.
- An engineer who works primarily in a terminal can run
code-assistant --tuifor project-scoped code investigation and modification. - A Zed user can expose Code Assistant as an external coding agent through its documented ACP command.
- A Claude Desktop user can run the application as a local MCP server and make its coding operations available to that client.
- A maintainer whose project mixes source code with PDFs or Office files can let the agent analyze those documents as Markdown alongside the codebase.
- A web developer can use browser sessions to navigate and interact with an application while retaining direct control of credential entry during login.
What are this agent's strengths and limitations?
- The interface reveals individual tool calls and the returned material supplied to the model, making autonomous behavior easier to audit.
- Formatter reconciliation keeps the agent's file state current without requiring a token-consuming reread after every formatted save.
- File writes preserve encoding, BOM, and CRLF or LF line endings, reducing unrelated file churn.
- One executable supports a native GUI, TUI, headless MCP server, and editor-facing ACP agent.
- Its provider selection includes multiple hosted services and Ollama, while document ingestion extends work beyond source files.
- Hosted models require credentials for the chosen provider, and any provider charges or service availability remain external dependencies.
- A source build requires Rust; Linux also needs numerous graphics, audio, Vulkan, and development libraries, while macOS needs MetalToolchain.
- Because the agent can edit files and execute commands, adopters must configure permission tiers and sandboxing to match the repository's risk level.
- Restricting tool access specifically to Git-tracked files inside the project is listed as a future direction rather than a completed safeguard.
- Early rejection of edits to files changed since the model last read them is still on the roadmap, leaving a documented stale-file failure case unresolved.
How do you install or deploy this agent?
The shortest path is to download a prebuilt release: Code-Assistant-macos-aarch64.app.zip for Apple Silicon, Code-Assistant-macos-x86_64.app.zip for Intel Macs, code-assistant-linux-x86_64.zip for Linux, or code-assistant-windows-x86_64.zip for Windows. Launch the application; its first-run Settings screen asks you to select a provider, paste an API key, and choose a model, after which you can add a project folder. To build from source, install Rust on macOS or Linux with curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh. Debian or Ubuntu additionally requires sudo apt-get install -y --no-install-recommends pkg-config build-essential libssl-dev libzstd-dev libfontconfig-dev libwayland-dev libx11-xcb-dev libxkbcommon-x11-dev libasound2-dev libvulkan1; macOS requires xcodebuild -downloadComponent MetalToolchain. Then run git clone https://github.com/stippi/code-assistant, cd code-assistant, and cargo build --release. The resulting executable is target/release/code-assistant.
How do you use this agent?
For the first working session, run code-assistant, configure a provider, API key, and model in Settings, add a project folder, and start a chat. Run code-assistant --tui for the terminal interface, or submit an initial task directly with code-assistant --task "Explain this codebase". For Zed, configure an agent server whose command is /path/to/code-assistant, whose arguments are ["acp", "--model", "Claude Sonnet 4.5"], and whose environment supplies ANTHROPIC_API_KEY. For Claude Desktop, add an MCP server named code-assistant in the Developer configuration, set its command to /path/to/code-assistant, use ["server"] as its arguments, and set the SHELL environment variable as shown in the repository example. Providers, models, external MCP servers, and skills can also be managed from the application's Settings screen.