Open source · MIT · Development preview

The best coding agents are CLIs.
Charter is their IDE.

Run Claude Code, Codex, Kimi Code, or the managed Charter Agent as first-class citizens. Let them form a visible Mission, work in parallel, and bring back evidence you can inspect before anything is accepted.

Get started G Star on GitHub S

Unsigned beta downloads for macOS (Apple Silicon) & Windows · Linux preview — or build from source in about two minutes

Act one — Delegate: the current Charter launcher, with the Agent and task options ready to start. Act two — Plan: the agent proposes a rate-limiting plan and waits for approval, with Approve plan and Edit plan actions. Act three — Work: a running Session shows live file activity while a steering instruction is ready in the composer. Act four — Review: completed work waits for review with changed files, a passed verification, and approval controls in one place.
One real delegation, four acts — captured from the running application.

Charter starts from a simple observation: the strongest coding agents live on the command line, while the nicest IDEs ship their own — and ask you to settle. You shouldn’t have to choose between the agent you trust and the cockpit you deserve.

Observable agent work, from prompt to proof.

One Session keeps the task’s conversation, files, terminals, verification, and review together.

One delegation, three moments

Every screen below is the real application working one Session: choose the hands, watch the work, judge the result.

01 · Delegate

One composer, every agent

Start the managed Charter Agent, or run your installed Claude Code, Codex, and Kimi Code CLIs natively — same Session model, same review gate, no switching product shells.

Choose the project, model, thinking level, and preset checks before the run. Those choices stay with the current Session.

  • Plan firstThe agent proposes steps, scope, and a verification approach before it writes. You approve, edit, or reject.
  • Four autonomy modesRead, Approve, Auto, or Full — pick how much rope each run gets, with hard safety boundaries intact.
  • Nothing auto-acceptsCompletion always parks at review — the agent never merges its own work.
Charter's current launcher with the Agent picker open: Charter Agent, Claude Code, and Codex, with task settings below.

02 · Observe

Evidence beside the conversation

While the agent runs, file writes, commands, diffs, previews, checks, and decisions form one chronological ledger — with timestamps and diffstats, live.

No digging through a wall of chat. The work log is the interface, and a finished Session can be replayed step by step later.

  • Checks against the real worktreeEvery result stays in the history — a re-run never erases a failure.
  • One timelinePlans, commands, diffs, and check results share one stream — no reconciling chat, terminal, and Git by hand.
The Session work log recording reads, writes with diffstats, a test run, and a passed verification — beside the inline diff it produced.

03 · Decide

Proof before approval

When the Agent finishes, the task becomes ready to review. Changed files, check history, and the final result are together, and each item opens.

Inspect a line-numbered diff. Run the recorded checks. Then request changes, roll back, or approve — whole, by file, or by hunk.

  • Approve at any granularityAccept the whole change, a single file, or one hunk — and roll back the rest.
Charter's review surface: outcome, changed files, a passed verification run, and Request changes, Rollback, and Approve actions.

Mission Fabric

One goal, split across agents

Start normally in Charter, Claude Code, Codex, or Kimi Code. The first time an Agent delegates, the current Session becomes a Mission; the original conversation stays in place.

The real Charter Mission workbench showing a recursive task graph, an open decision that needs the user, progress, Results and Updates tabs, and evidence for the selected Agent.
Ownership, dependencies, Agent messages, open decisions, runtime identity, and evidence in one Mission graph.

Durable Sessions

Close the app. The Session stays.

Conversation, PTY state, files, previews, checks, decisions, and evidence are saved with the task. Reopen the app and continue where you stopped.

Live

See what is changing now

Current tool, file heat, command blocks, child Agents, Preview errors, and queued steering all update from the same event stream.

Return

Reopen the same Session

Real PTYs and supported Claude Code, Codex, or Kimi Code identities persist when you switch pages and through app restarts. External sessions can be discovered, opened, and adopted.

Recall

Open the result, process, or evidence

Recap summarizes the result, Explore shows the process, and Verify collects the evidence. Download an HTML or JSON receipt with the changes, checks, and final actions in order.

Context handoff — stop copying context by hand

  • FilesDrop in a file or folder, or type @ to search by name. Source paths stay attached.
  • CodeSend only the lines you selected — with file path, line numbers, and version.
  • TerminalSelect output and click Send to Room. Screenshots and annotations return to the same Session.

Take over whenever you need to

Editor, terminal, Git, project search, and live preview share the same Session. Follow the Agent’s work, then open a file and keep editing when you need to step in.

Project Center
branch, state, Sessions & Missions together
⌘K / ⌘P
search everything, open files by name
File Peek
open files & diffs beside the Session
Skills
managed workflows, invoked with /
Steer mid-flight
redirect, queue follow-ups, or stop
Needs you
only Sessions waiting on you, grouped
Git built in
stage, commit, and switch branches
Project search
ripgrep-fast, with replace previews
Code intelligence
TS/JS smarts, Python basics
Completion notices
toned alerts when any Session finishes
External sessions
discover & adopt outside CLI runs
Screenshots to Agent
send, annotate, or file captures
⌘-click paths
jump from terminal output to the line
Rich previews
images, PDFs, HTML & Markdown inline
Quick Console
Option+Space for a scratch terminal anywhere
Five themes
Studio, Terminal, Archive, Index & Atelier

Remote development

Use the same workspace on a remote repository

Save hosts, open multiple shell Sessions, transfer files, and forward ports in Charter. Long-running work continues when you switch pages, with progress kept visible.

  • Real SSH SessionsRemote shells live in the same rail and keep their PTY state.
  • Dual-pane SFTPMulti-select, drag across panes, cancel, retry, and never overwrite silently.
  • Global transfer centerProgress, speed, failures, and retries remain visible across surfaces.
  • Port forwardsCreate local forwards from the host, including a single-hop jump host.

Download the beta or run from source

Charter is a development preview: the desktop workflow is implemented and tested. Grab the unsigned beta for your platform, or build from source in about two minutes.

macOSApple Silicon · beta Windowsx64 · beta Linuxpreview tarball

Unsigned builds, not notarized — your OS may warn before first launch. Every release publishes SHA256SUMS.txt, an SBOM, and a manifest: verify your download on GitHub Releases.

terminal
# Node.js ≥ 22.19, npm, and Git
$ git clone https://github.com/longyunfeigu/Charter.git
$ cd Charter && npm install
$ npm run dev
  1. Open a Git project. Charter works on real repositories, in isolated worktrees.
  2. Add a model provider. Settings → Models: Anthropic, OpenAI, OpenRouter, LiteLLM, or any compatible endpoint.
  3. Start a Session. Choose the Agent and describe the outcome you want. When it is ready to review, open the diff and check results.

Questions, answered plainly

Why are the downloads unsigned?

Unsigned installers are a known limitation of the current beta. Code signing, notarization, and in-app replacement are still in progress. Beta 4 can detect a newer prerelease and open its verified GitHub page, but installation remains manual. Until then the beta ships unsigned, so your operating system may warn before first launch. Every release publishes SHA256SUMS.txt, an SBOM, and a manifest — verify what you download, or build from source if unsigned apps aren’t allowed on your machine.

What is a Mission?

A Mission is a durable team formed when an Agent delegates work. It records recursive ownership, task dependencies, direct Agent-to-Agent messages, runtime attempts, user decisions, and evidence separately. You can inspect or steer any assignment, and the whole Mission stops at review instead of accepting itself.

Can I edit while the Agent is running?

Yes. Keep editing in the Files workspace for the same Session; the Agent does not take your cursor when it writes. Add direction in the current composer or stop the run when needed.

Which models and agents can I use?

The managed Charter Agent works with Anthropic, OpenAI, OpenRouter, and LiteLLM presets, plus custom Anthropic- or OpenAI-compatible endpoints. Installed Claude Code, Codex, and Kimi Code CLIs run natively inside the same Session and review model.

How is this different from an AI-first IDE?

Charter runs your locally installed Claude Code, Codex, and Kimi Code CLIs with their real PTYs and original sessions. Files, diffs, Preview, check results, and Replay stay in the same Session.

Is it really open source?

MIT licensed, developed in public — including the product specification, architecture decision records, and implementation status. If a claim on this page isn’t backed by the repository, file an issue.

Who builds Charter?

Mostly coding agents — working the way this page describes, against a public specification, with plans, verification, and review on every change. The gates exist because Charter’s own development depends on them.

Charter your agent.

Give the work a charter — goal, boundaries, proof — and keep the final say.

Get started View on GitHub