Dev & Engineering coding-clideepseektask-decompositionshell-executioncode-difftest-automationmcp-testingmulti-agent-collaboration

Carbon Code

A DeepSeek-powered coding CLI that decomposes tasks, proposes code changes, and validates them with tests.

FollowAgents review · FARS-2.1
Use with care
64/ 100 5-point scale 3.2 / 5
1 2 3 4 5 6
Per-dimension scores and reasoning
1Trust18 / 29 · 3.1/5

The materials show approval gates for commands, edits, plan checkpoints, and out-of-sandbox path access in ordinary modes; chat mode has no filesystem or shell tools, and initialization protects existing rule files by default. However, an explicit yolo mode automatically permits commands, background processes, and path access, and no complete permission matrix is supplied. Default diagnostic collection, excluded content, the offline queue, and opt-out controls are described, while key storage and non-commit guidance are documented; file permissions, encryption at rest, and rotation are not shown. CI runs scheduled CodeQL with narrow permissions and dependencies are declared, but no lockfile, dependency audit, or vulnerability-response evidence is included. External effects are approval-controlled, yet no general edit recovery, command undo, or rollback design is demonstrated. MIT and third-party notice locations, author, and repository metadata are present, but the publisher is unverified and the relationship between “Reasonix Contributors” in LICENSE and Yapie0 in package metadata is unexplained.

2Reliability9 / 14 · 3.2/5

The README, package metadata, CI, and supplied tests are broadly consistent about command names, Node.js requirements, approval behavior, MCP loading, and session records. Dependencies are declared and npm ci feeds verification on Ubuntu and Windows, but the evidence does not establish comprehensive fallback behavior when model services, npm packages, or MCP servers are unavailable. MCP initialization and parse failures are logged, failed clients are closed, processing continues, and a setup hint is tested. Only a narrow set of failure paths is covered, so actionable handling for network, authentication, write, and shell failures is not established.

3Adaptability15 / 18 · 4.2/5

The target audience and personal-development workflow are explicit, with distinct entry points for installation, chat, one-shot tasks, project initialization, health checks, and updates, fully supporting the audience-and-scenarios criterion. Tool-free chat, security scope, third-party MCP exclusions, and edit modes define meaningful boundaries, but yolo risk and ACP/MCP options are not fully documented in the main README. Command triggers are reasonably precise and tests cover MCP prefixes and disabled servers, although some tested commands and options lack matching user-facing documentation. Node.js 22 requirements, a PowerShell workaround, dual-platform CI, environment variables, and configuration paths provide thorough environment-fit evidence.

4Convention11 / 18 · 3.1/5

The README sensibly organizes installation, commands, configuration, diagnostics, licensing, and links to further guidance, but the supplied files do not provide complete navigation or a comprehensive reference. Installation covers global, one-off, and Windows usage and earns full marks. The carboncode/ccode names are stable and the avoidance of cc is explained, though lingering Reasonix names reduce consistency. There are useful examples and one common PowerShell remedy, but no systematic FAQ. Limitations are only scattered through scope and mode descriptions rather than documented comprehensively. The MIT text agrees with package metadata and third-party license locations are named, justifying full license credit. A 0.2.14 version is present, but no changelog or compatibility policy is shown. Maintenance routing is limited to repository issues and a vague instruction to contact the owner privately, without a named team, response policy, or verified identity.

5Effectiveness7 / 13 · 2.7/5

The command design, plan approvals, validation workflow, concise session trail, and transcript tests covering tool arguments, usage, and cost indicate ordinarily usable development output. Automatic tasks, MCP, multi-agent, and provider support could add material value, and some mechanisms are tested, but the supplied tests focus on ACP/MCP and approval edge cases rather than the complete autonomous-development proposition. Claims of more than 90% token savings and capability near Claude Sonnet 4.6 have no benchmark, methodology, dataset, or results, so cost-benefit evidence is thin.

6Verifiability4 / 8 · 2.5/5

Some operational claims trace to package scripts, CI, and tests, including cross-platform verification, non-fatal MCP failures, approval modes, and transcript fields. Core marketing claims have no benchmark or experimental record, limiting traceability. The README, package metadata, workflows, security policy, and tests corroborate several facts, supporting an ordinary cross-source score. The material does not clearly distinguish tested facts, design intent, and speculative comparisons—especially the “first,” “over 90%,” and “approaching Sonnet 4.6” claims—so fact/inference separation remains weak.

Evidence confidence: Low Reviewed Sep 22, 2026 Reviewed revision 9cc02818776e
Before you use it
  • Yolo mode automatically permits shell commands, background processes, and out-of-sandbox path access; assess it explicitly before use in repositories containing credentials, production configuration, or important uncommitted work.
  • Redacted error/fatal metadata and stack traces are collected by default. Sensitive environments should inspect the actual redaction, queue permissions, and upload destination, or disable diagnostics first.
  • Do not treat the “over 90% token savings,” “first in China,” or “approaching Claude Sonnet 4.6” statements as verified; the supplied evidence contains no supporting benchmark.
  • The configuration file is designated as a credential store, but permission hardening and encryption at rest are not shown. Restrict access to ~/.carboncode/config.json and prefer controlled environment variables or a secret manager where appropriate.
  • Third-party MCP servers are expressly outside the security-policy scope; review their code, permissions, and data flows separately before installation.
Review evidence [1][2][3][4][5][6][7][8][9]
See the full review method →

What does this agent do, and when should you use it?

Carbon Code is a TypeScript terminal coding agent whose default model presets target DeepSeek V4. Launched inside a project, it reads and searches the codebase, proposes changes as diffs, requests approval before shell execution, and runs tests when needed. Its interfaces include interactive coding, tool-free chat, one-shot non-interactive tasks, and project-guidance generation. The CLI installs the `carboncode` and `ccode` commands, stores user configuration in `~/.carboncode/config.json`, and recognizes repository guidance in `AGENTS.md` or `CARBON.md`. A desktop client also supports standard OpenAI-compatible providers, including model discovery through `/models` and adaptation between the Responses and Chat Completions APIs. It is aimed at developers who want an agent operating against a local repository while retaining an approval checkpoint for commands.

A typical session starts with carboncode or carboncode code [dir]. The agent reads and searches project files, decomposes the task, proposes edits, and presents the resulting changes as a diff. It asks for confirmation before running shell commands, can execute tests to validate the work, and leaves a concise session record. carboncode run "task" performs a single non-interactive task, while carboncode chat removes filesystem and shell tools. carboncode init [dir] reads manifests, directories, and tool configuration to generate CARBON.md without calling a model. The documented command set also includes carboncode doctor, carboncode update, MCP testing, and collaboration with agents such as Claude and Codex. Model presets map flash to deepseek-v4-flash, pro to deepseek-v4-pro, and auto to Flash with a one-time escalation to Pro on a difficult turn.

  1. A DeepSeek API user who wants an interactive terminal agent to inspect a local repository, propose diffs, and help implement changes.
  2. A team that needs a one-shot coding task in a script or automation flow through carboncode run "task".
  3. A maintainer onboarding to an existing project who wants to preview and generate a CARBON.md guide with carboncode init --dry-run.
  4. A developer who wants agent-run tests and shell commands but requires an explicit confirmation step before command execution.
  5. A team evaluating MCP tests or workflows that coordinate Carbon Code with Claude or Codex.
  6. A user who only wants a conversation and does not want the session to receive filesystem or shell tools, using carboncode chat.

What are this agent's strengths and limitations?

Pros
  • Covers a concrete local-development loop: code search, task decomposition, diff review, command approval, and test validation.
  • Offers interactive coding, tool-free chat, and one-shot carboncode run modes for both manual and scripted workflows.
  • carboncode init does not invoke a model and includes dry-run and no-overwrite-by-default safeguards.
  • The desktop client supports standard OpenAI-compatible providers, discovers /models, and adapts between Responses and Chat Completions APIs.
  • MCP testing and collaboration with Claude and Codex are explicitly identified as supported capabilities.
Limitations
  • The CLI requires Node.js 22 or newer, creating an upgrade requirement for older environments.
  • The default provider path requires a DeepSeek API key; the claimed 90%+ token-cost saving is not accompanied by benchmarks, methodology, or billing evidence in the supplied material.
  • Desktop installation and deployment instructions are absent from the supplied material, even though provider configuration is described.
  • The material does not provide setup steps, support boundaries, or validation examples for MCP testing and Claude/Codex collaboration.
  • Redacted error and fatal diagnostics are uploaded by default, so organizations with strict telemetry policies must disable the feature and account for its offline pending-event directory.

How do you install or deploy this agent?

Install Node.js 22 or newer and obtain a DeepSeek API key.

Install globally and start it in a project:

npm install -g @carboncode/cli
cd path/to/project
export DEEPSEEK_API_KEY=sk-...
carboncode

The installed shorthand is ccode. To avoid a global installation, run npx @carboncode/cli. If PowerShell blocks npm.ps1, use npm.cmd install -g @carboncode/cli. The first-run wizard can also configure the DeepSeek API key, and persistent user settings live at ~/.carboncode/config.json.

How do you use this agent?

Run carboncode in the current project or carboncode code [dir] for a specified directory. Review the proposed plan and diff, then approve or reject shell-command requests and allow tests when appropriate. Use carboncode run "task" for one non-interactive job, carboncode chat for a session without filesystem or shell tools, and carboncode doctor to check the local environment. For project guidance, run carboncode init --dry-run before carboncode init; existing guidance files are preserved by default, while carboncode init --force --yes explicitly permits replacement. Run carboncode update to check for and install the latest CLI package. In the desktop client, an OpenAI-compatible provider can be added under Settings -> Models -> Add model provider by entering its Base URL and API key.

How does this agent compare with similar options?

The project positions Carbon Code as similar to Claude Code and says its capability approaches Claude Sonnet 4.6, while emphasizing DeepSeek as the default provider and claiming more than 90% token-cost savings. The supplied material contains no matched-task evaluation, quality benchmark, latency results, or cost methodology, so those capability and cost comparisons remain project claims rather than independently supported measurements. Carbon Code also documents standard OpenAI-compatible provider support in its desktop client.

FAQ

What credentials are required?
The default model path requires a DeepSeek API key, supplied through the first-run wizard or DEEPSEEK_API_KEY. An OpenAI-compatible provider in the desktop client requires that provider's Base URL and API key.
Can it execute local commands without asking?
The documented workflow says Carbon Code requests confirmation before running shell commands. Users who want no filesystem or shell access can choose carboncode chat.
Does diagnostics upload source code or conversations?
The documentation says the default diagnostics upload contains redacted error/fatal metadata and stack traces, not conversations, model output, file contents, full command arguments, API keys, tokens, cookies, or environment-variable values. It can be disabled with CARBONCODE_DIAGNOSTICS=off or {"diagnostics":{"enabled":false}}.
What happens to diagnostics when the network is unavailable?
Events are temporarily stored in ~/.carboncode/diagnostics/pending/ with count and size limits. The supplied material does not state the numerical limits.
Will project initialization overwrite existing guidance or call a model?
carboncode init only reads repository manifests, directories, and tool configuration and does not call a model. Existing guidance files are not overwritten by default; use --dry-run first and pass --force only when replacement is intended.

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents