Open-Source Alternatives to T3 Code for Running Coding Agents

If you want an open-source alternative to T3 Code, look at Zed (GPL), Cline (Apache 2.0), Kilo Code (MIT) and OpenHands Agent Canvas (MIT). Each gives a coding agent a graphical home. None of them checks the dependencies that agent pulls in, so run a scanner like the Safeguard CLI next to whichever one you pick.

T3 Code is popular partly because it lets you use AI subscriptions you already pay for. The Safeguard CLI works the same way. Bring the Claude or ChatGPT plan you already pay for and use it inside the Safeguard CLI. Safeguard adds no extra charge for that usage; your plan's own usage limits and terms still apply.

This guide covers what T3 Code is, four maintained open-source alternatives and three that have stopped, and how to choose between them. It then walks through setup with real commands and lists common mistakes. The last part shows how to write, fix and check code properly with the Safeguard CLI, whichever front end you use.

What T3 Code is

T3 Code comes from the ping.gg team and lives at github.com/pingdotgg/t3code. Its README calls it a control surface for the coding agents already installed on your machine. It ships as an Electron desktop app, a web app, and mobile apps for iOS and Android. It can also run as a local server, started with the t3 command, that you open in a browser.

T3 Code does not come with a model of its own. It drives agents that you have already installed and signed in to: Codex, Claude Code, Cursor, Grok Build, OpenCode and Google Antigravity. The README tells you to install and authenticate at least one provider before you use it. For example, you run claude auth login for Claude Code or codex login for Codex. Once those agents are set up, T3 Code controls them with the subscriptions you already have.

The project is MIT licensed, so T3 Code is itself open source. You can read it, fork it and run it without a commercial agreement with ping.gg.

Before you adopt it, know two things. The README says the project is "very very early" and tells you to expect bugs. The team is also mostly not taking contributions, so you can fork it, but big features are unlikely to land upstream.

People look for alternatives for a few reasons:

• They want the agent inside their editor rather than in a separate window.
• They want a tool that comes with its own agent and model choice, instead of wrapping agent CLIs they have to install first.
• They want to self-host the agent somewhere other than their laptop.
• They need something with a longer track record for a team rollout.

The open-source alternatives, compared

Every tool below is open source, and we checked each licence on the project's own GitHub page. They are listed in no particular order. This is a comparison of what each tool is, not a ranking.

Comparison table

Zed

Zed is a code editor from Zed Industries for macOS, Linux and Windows. It is licensed mainly under GPL-3.0-or-later, with some Apache-2.0 parts. It has its own built-in agent, and its Agent Panel can also run external agents over the Agent Client Protocol (ACP). The docs list Claude, Codex, Gemini CLI, OpenCode, Copilot, Cursor, Pi and Poolside, and you can add any ACP-compatible agent yourself.

Before you adopt it: external agents handle their own sign-in, keys and billing. Keys you set up for Zed's built-in agent do not carry over, and Zed's agent profiles and skills mostly do not apply to external agent threads.

Cline

Cline is an Apache-2.0 coding agent. It comes as a VS Code extension, a CLI, a desktop app for macOS and Windows, a JetBrains plugin and an SDK. It supports a long list of providers, including local models through Ollama or LM Studio. In Plan mode it explores your code and proposes a strategy. In Act mode, every file edit and terminal command needs your approval unless you turn on auto-approve.

Before you adopt it: according to the repository's own index, the JetBrains plugin is not open source. If being fully open source matters to you, stick to the VS Code extension or the CLI.

Kilo Code

Kilo Code is an MIT-licensed agent that runs as a VS Code extension, a JetBrains plugin and a CLI. The CLI is a fork of OpenCode. It ships Code, Plan, Ask and Debug agents, and you can define your own. The README says you pay the model provider's rate with no markup, and that you do not need API keys to start.

Before you adopt it: kilo run --auto approves permission prompts unless a rule explicitly denies the action. The project itself says to use it only in trusted environments.

OpenHands Agent Canvas

Of the four, this is the closest match to T3 Code. The OpenHands repository, MIT licensed, now centres on Agent Canvas, which it describes as a self-hosted control centre for coding agents. It runs the OpenHands agent by default, and from the same local web UI it can also drive Claude Code, Codex, Gemini CLI, OpenCode and other ACP agents. You can point it at an agent server on your laptop, a VM, your own infrastructure or OpenHands Cloud.

Before you adopt it: the project is in beta. If you install it without a Docker sandbox, the README warns that the agent has "full access to your filesystem".

Projects that have stopped

Some names still show up on alternatives lists but are no longer developed:

• Void, an Apache-2.0 fork of VS Code, was archived on 2 June 2026 and is marked deprecated.
• Roo Code (Apache-2.0) says its extension shut down on 15 May 2026, and its repository is archived.
• Continue (Apache-2.0) says its repository is no longer actively maintained and is read-only.

You can still read and fork all three. Just don't plan a team rollout around them.

How to choose

GUI or terminal. If you want to watch several agents work side by side, Agent Canvas and T3 Code are built for that. If you'd rather review diffs where you already write code, Zed, Cline or Kilo Code put the agent in your editor. If you live in the terminal, Cline and Kilo Code both have CLIs, and the Safeguard CLI runs there too. You can also mix them, with a GUI for long agent sessions and a terminal for quick tasks and CI.

Which models. T3 Code, and Zed's external agents, run on your existing agent subscriptions. Cline and Kilo Code let you pick a provider directly, and Cline also supports local models. If your company has approved one provider, check that the tool supports it before you test anything else. If cost is the concern, see how each tool bills. Some use your existing plan, some charge provider rates, and some need a separate API key.

Local or cloud. All four can run on your own machine. OpenHands can also put its agent server on a VM, your own infrastructure or its hosted cloud, and Kilo Code has a Cloud Agent. Wherever the agent runs, check what it can reach: your home directory, your SSH keys, your cloud credentials.

What none of them do. A front end decides how you watch and approve an agent's work. It does not tell you whether the package the agent just added has a known vulnerability. Every tool in this post can add or upgrade dependencies, and none of them checks those packages against vulnerability data. That check has to happen somewhere else before you merge. For a recent example of agent tooling coming under attack, read our post on the OpenCode console breach and provider API keys.

Setup walkthrough and worked examples

Every command below comes from the project's own README or docs.

Step 1: Install the front end

T3 Code, as a local server on macOS or Linux:

curl -fsSL https://t3.codes/install.sh | sh
t3

You can also try it without installing (npx t3@latest), or install the desktop app (brew install --cask t3-code on macOS, winget install T3Tools.T3Code on Windows). Then sign in to at least one agent, for example claude auth login or codex login.

Zed:

# macOS
brew install --cask zed

# Linux
curl -f https://zed.dev/install.sh | sh

On Windows, use winget install -e --id ZedIndustries.Zed. To add an external agent, open Agent Settings, go to External Agents, click Add Agent and choose Install from Registry. The agent then shows up in the new-thread menu in the Agent Panel.

Cline CLI:

npm i -g cline
cline "Run tests and fix any failures"

Kilo Code CLI:

npm install -g @kilocode/cli
kilo

OpenHands Agent Canvas, with each conversation in its own Docker container (needs Node.js 24 or later, uv and a running Docker):

npm install -g @openhands/agent-canvas
OH_CONVERSATION_RUNTIME=docker agent-canvas

The UI opens at localhost on port 8000.

Step 2: Install the Safeguard CLI next to it

# macOS and Linux
curl -fsSL https://cli.safeguard.sh/install | bash

Run safeguard, type /login and sign in through the browser. The Safeguard CLI section below covers this in more detail.

Step 3: Let the agent work, then check its changes

Here is a typical loop. You ask your agent, in any of the tools above, to add a feature. It edits a few files and adds two packages to your manifest. Before you open a pull request, scan the folder:

safeguard scan --dir .

This builds an SBOM for the folder and matches it against vulnerability databases. The results are written as JSON files under ./output, including vuln.json and license.json.

Worked example: fix what the scan found

Say the scan reports a vulnerable version of lodash that came in with the agent's change. Open the interactive terminal in the same folder:

safeguard

Then ask in plain language:

/scan .
fix the lodash CVE in this repo

The assistant reads your files and your Safeguard data, proposes an edit and asks before it writes the file or runs a command. Run safeguard scan --dir . again afterwards to confirm the finding is gone.

Worked example: review a diff from the terminal

Cline's README shows piping a diff into its CLI for review:

git diff origin/main | cline "Review these changes for issues"

That review is about code quality. Pair it with a dependency check of the same working tree:

safeguard scan --dir .
safeguard exec "summarise the critical findings in this repository"

Worked example: the container image the agent built

Agents often change a Dockerfile as well as code. If yours did, scan the image too, not just the source folder:

docker build -t myapp:dev .
safeguard scan --image myapp:dev

If another tool already produced an SBOM, scan that instead with safeguard scan --sbom, and check that it is well formed with safeguard validate, which supports CycloneDX, SPDX and VEX documents.

Common mistakes

Treating the front end as the security check. Approval prompts show you what the agent is about to do. They don't tell you whether a package version is safe. Scan before merge, whatever front end you use.

Turning on auto-approve in a repository you don't trust. Cline's auto-approve, kilo run --auto and the Safeguard CLI's Yolo mode all remove the pause before an action. They are fine in a throwaway sandbox and risky on a laptop that holds your credentials.

Running OpenHands without a sandbox on your main machine. The no-sandbox install gives the agent full filesystem access, and the README says so. Use the Docker options unless you have a reason not to.

Assuming keys carry over. In Zed, external agents handle their own auth, and keys set up for Zed's built-in agent don't apply to them. In T3 Code, each provider CLI needs its own login. Plan for one sign-in per agent.

Adopting an archived project. Void, Roo Code and Continue still turn up in search results. Check the repository banner before you build a workflow on any of them.

Scanning only the source. If the agent touched a Dockerfile, the image can pull in packages your source manifest never mentions. Scan the image as well.

Expecting the CLI to block merges by itself. In Safeguard, policies and gates are evaluated in the platform, not by the CLI. Use the CLI to find and fix issues, and use platform gates to enforce rules.

Do the work properly with the Safeguard CLI

Whatever front end you prefer, run the Safeguard CLI next to it. It is not only a scanner. It writes and fixes code with an assistant that also knows your vulnerabilities. You can use it to check every change for vulnerable dependencies before you merge, and to keep your source code on your own machine.

The CLI scans code, container images and SBOMs on your machine, sends only the results to the platform, and includes an assistant that can fix what it finds.

Install

It is a single static binary, so you don't need Node, Python or a JVM. It runs on macOS, Linux and Windows, on x86_64 or arm64. On Windows it is x86_64 only.

# macOS and Linux
curl -fsSL https://cli.safeguard.sh/install | bash

# Windows (PowerShell)
irm https://cli.safeguard.sh/install.ps1 | iex

First session

Run safeguard with no arguments to open the interactive terminal. Type /login to sign in through your browser, then /scan . to scan the current folder. After that, you can ask questions in plain language, such as "how many critical vulns do we have".

A few commands help in longer sessions:

• /model shows the current AI model or switches to another.
• @ attaches a file from the folder you started in.
• /resume picks up your last session in that folder, which helps when a fix spans more than one sitting.

Writing and fixing code

The assistant has tools for your local files and for your Safeguard data. It can write files, edit code and run commands. That means you can ask it to make a change, not just to explain a finding: "fix the lodash CVE in this repo" is a normal request. Because it can also see your Safeguard data, it works from the same findings your scans produced.

Use your Claude or ChatGPT plan

This is the part that parallels T3 Code. T3 Code lets you drive agents with subscriptions you already have, and so does the Safeguard CLI. Bring the Claude or ChatGPT plan you already pay for and use it inside the Safeguard CLI. Safeguard adds no extra charge for that usage; your plan's own usage limits and terms still apply.

To connect a model or switch between models, use /model in the interactive terminal, and see the CLI docs for current setup details.

Approvals

Actions that change things ask before they run. /permissions sets the approval mode:

• Ask prompts before every action.
• Auto approves actions it already knows and asks for anything new. This is the default.
• Yolo approves everything. Keep it for throwaway environments.

Scans you can script

safeguard scan --dir .
safeguard scan --repo <url>
safeguard scan --image <name>
safeguard scan --sbom <file>

Each scan builds an SBOM and matches it against vulnerability databases, then writes JSON results under ./output (vuln.json, license.json and others). A separate command, safeguard validate, checks CycloneDX, SPDX and VEX documents.

CI with safeguard exec

safeguard exec runs one non-interactive assistant turn, so it fits into a CI job:

safeguard scan --dir .
safeguard exec "summarise the critical findings in this repository"

When the local runner runs platform scan jobs, your source code never leaves the machine. Only SBOMs and findings are uploaded. In the platform, policies and gates decide what blocks a release, reachability analysis shows whether vulnerable code is actually called, and autonomous remediation can open fix PRs. That last feature is off by default.

Install it from safeguard.sh/download, and keep the CLI docs open for the full command reference.

FAQ

Is T3 Code open source?

Yes. The pingdotgg/t3code repository is MIT licensed. It does not include a model. It controls agents like Codex and Claude Code, which you install and sign in to separately.

Which open-source alternative is closest to T3 Code?

OpenHands Agent Canvas. Like T3 Code, it is a control surface for several coding agents, and it can drive Claude Code, Codex, Gemini CLI and OpenCode. It also has its own default agent and Docker sandbox options. It is in beta.

Can I use my Claude or ChatGPT plan with the Safeguard CLI?

Yes. Bring the Claude or ChatGPT plan you already pay for and use it inside the Safeguard CLI. Safeguard adds no extra charge for that usage; your plan's own usage limits and terms still apply. Use /model and the CLI docs to connect it.

Does the Safeguard CLI replace T3 Code, Zed or Cline?

Think of it as something you run next to them, not a swap. Use whichever front end you like for agent sessions. Use the Safeguard CLI to write and fix code with vulnerability context, and to scan what any agent changed before you merge.

Does my source code leave my machine?

Not when the local runner runs platform scan jobs. The CLI scans on your machine and uploads only SBOMs and findings.

Can I run these tools with local models?

Cline lists Ollama and LM Studio for local models. OpenHands says you can bring your own model. For the other tools, check each project's docs. Their README pages do not say.

What happened to Void, Roo Code and Continue?

Void and Roo Code are archived, and Continue's repository says it is no longer actively maintained and is read-only. Their code is still available to read and fork.

How do I stop a vulnerable dependency from reaching main?

Scan in CI with safeguard scan --dir ., and enforce the rule with policies and gates in the Safeguard platform. The CLI finds and fixes issues; the platform evaluates the gate.

Try it yourself

Click through it at your own pace, or open it full screen.

Quick check

Sources

• T3 Code repository (pingdotgg/t3code)
• T3 Code licence
• Zed repository
• Zed docs: External Agents
• Zed docs: Installation
• Cline repository
• Cline licence
• Kilo Code repository
• Kilo Code licence
• OpenHands repository
• OpenHands licence
• Void repository
• Roo Code repository
• Continue repository
• Safeguard CLI docs

Last reviewed: 20 October 2026.