golder-cli.pages.dev · Go · MIT

An AI coding agent for desktop, Android and terminal

Golder is an open-source AI coding agent written in Go. Manage projects, conversations, tools and approvals in a native GUI; run the shared Agent in a native Android app with on-device tools and APK install; run the agent, a shell and a browser side by side in a terminal workspace; or use the CLI, REPL and headless mode.

$curl -fsSL https://golder-cli.pages.dev/install.sh | sh
This command installs the CLI; use the button above to choose the desktop app. Browser features can use an installed Chrome or Chromium.

Get started in three steps

The desktop app and CLI are installed separately. Choose the entry point that fits your work.

Try Golder GUI

Choose the download for your computer. Open a project and configure a model and credential in Settings to start a conversation.

Choose the desktop app for your computer

We put your detected operating system first; we do not guess your processor.

Could not reliably identify this device. Choose your computer system below.

Checking the latest packages. If this does not load, the buttons lead to GitHub.

Mac For this system

Not sure which chip? Open the  menu → About This Mac and check Chip or Processor.

Open the DMG and drag Golder GUI to Applications. Requires macOS 14 or later.

Windows For this system

For 64-bit Intel / AMD PCs. Open the downloaded installer.

On Windows ARM, first check compatibility with x64 apps.

Linux For this system

Choose .deb for Ubuntu / Debian, or an archive for other distributions. Match your computer architecture.

Recent macOS packages are Developer ID signed and Apple-notarized. On first launch, macOS may ask to confirm opening an app downloaded from the internet; Accessibility or Screen Recording prompts may still appear.

View all versions and files on GitHub ↗
1

Install the CLI

Use Homebrew on macOS or the one-line script on Linux; Windows users can download the CLI .zip from Releases. The desktop app is a separate download.

$ brew install getan/tap/golder
$ curl -fsSL https://golder-cli.pages.dev/install.sh | sh
2

Configure a credential

The default gateway (OpenCode) needs a single API key; any OpenAI-compatible endpoint or a local Ollama works too.

$ export OPENCODE_API_KEY=...
3

Open a terminal workspace

golder workspace opens the global default: the agent in the first pane, Ctrl+b c for a shell, and the agent opens the browser itself when needed. Ctrl+b d detaches; the daemon and its panes keep running. golder workspace -s coding enters another named session from any directory, and list / attach / stop all address a name. Already used to tuios / herdr / tmux / zellij / screen? Run the single-agent golder in its pane instead.

$ golder workspace
$ golder workspace -s coding   # another named session
$ golder   # already in a multiplexer: single agent

Why golder

A shared Agent core for desktop, Android, terminal and automation.

A native Android app

Kotlin/Compose runs the shared Go Agent over JNI. Keystore-backed credentials, a foreground service for background tasks, structured Git, GitHub Actions APK build/download and an Install APK action keep the mobile workflow on the phone.

A native desktop workspace

Golder GUI uses MyGo native UI for projects, sessions, streamed conversations, diff cards and approvals, with file and change views, a browser surface and an optional terminal. It reuses the Agent core rather than wrapping a TUI.

A built-in terminal workspace

golder workspace runs the agent, a shell and the browser in one panel (no separate tuios or kitty-browse install on macOS / Linux): the agent patches on the left while the shell runs tests on the right, and focus is input. The agent opens the browser itself through the browser tool’s open action (profile and socket under .golder/browser/), then drives pages with snapshot/click/fill/wait/console/network; presets (debug-fullstack, data-analysis, review) start backend, frontend and browser together, and snapshot hands the model every pane’s context at once.

Hot-switch providers; the session outlives them

/provider switches gateways at any time and /resume continues the same context on the new provider; 19 built-in conversation gateways cover OpenAI Chat / Responses, Anthropic Messages and Gemini, plus any compatible endpoint.

Lightweight like pi, with a real security boundary

Applicable tool calls are governed by permission modes, approvals, path grants and OS sandboxing (sandbox-exec / bubblewrap). Default sandboxed reads and writes are scoped, and tool network access is granted per call; actual boundaries depend on platform and configuration.

Easier to customize than codex-cli

Pure Go: one language, one binary, no Node/Python runtime. A new tool, provider or approval rule is one go build away.

A lightweight CLI; a separate desktop app

The CLI is a Go-compiled program. The separately distributed GUI adds a graphical workspace, terminal and browser surface as needed.

Extend without touching the core: CLI / MCP / Skills

/extensions manages declarative CLI tools, standard MCP services (stdio/http with tools/prompts/resources), legacy RPC plugins and Skills in one place. A source must be explicitly trusted, and the first connection shows its executable, manifest/URL and network ceiling. Every external tool call still goes through the same approval gate, so extensions never require changing the core.

From interface to Agent: how Golder works

A map of the desktop, Android, terminal, models, tools and permission boundaries.

Golder architecture diagram: GUI, Android, terminal and CLI connect to the Agent runtime, models, tools, Android CI, Android app control and security boundaries
Diagram labels are in Chinese. This overview is simplified; actual permissions and platform support depend on the tool and configuration.
A real golder workspace session with the agent, a backend shell and a browser side by side
TUI workspace The agent, a backend shell and a browser in one terminal workspace.
Golder GUI with project and session navigation, Agent conversation, approvals and an architecture preview
Desktop GUI Projects, sessions, Agent conversation, diffs and approvals.
Golder Android main session showing an Android build result, the Install APK action and context usage
Android main session The same Agent core runs on the phone over JNI; a build result can install directly, and context usage is restored after reopening the app. Android demo: a successful GitHub Actions build, the Install APK action and 6% context usage.
Terminal workspace — browser and backend together
A real session: the agent develops and checks a backend while using the browser in the same workspace (3:31, 4× speed).

01 / Choose an interface

The native GUI, Android app, TUI / REPL, CLI and workspace use the shared Agent core; Android connects over JNI, while a workspace daemon and its agent panes are separate processes.

02 / The Agent loop

The runtime assembles context, calls the selected model, executes tools and continues the conversation. Sessions, compaction and memory help work continue.

03 / Capabilities and boundaries

Files, Git, shell, web, MCP, Skills and Android build/download/install tools connect local and external resources. Applicable calls pass through permissions, approvals, path grants and sandboxing before reaching a project, browser, window or Android package.

More features

Safety boundaries, long tasks, and session management are built in — the parts you actually use every day.

Android builds without repeated CI

android_build reuses a successful workflow for the current commit; android_download fetches an existing artifact; android_install or the transcript’s Install APK action opens the system installer without rebuilding.

GitHub login on Android

Device-code login (like gh auth login) is the default, with a Fine-grained PAT tab for least privilege. PAT needs Contents, Workflows and Actions read/write. Sign out clears local tokens; revoke authorization on GitHub.

Desktop, terminal and headless

The native GUI and CLI are separate builds sharing Agent capabilities. Choose a split-pane workspace, full-screen TUI or line REPL in the terminal; headless -p and stream-json support scripts and CI.

Desktop windows and browser

The browser surface uses a locally installed Chrome or Chromium; compatibility with other Chromium-based browsers varies by product and platform. Computer Use is under development and can attempt to observe and operate a user-selected window; permissions and capabilities vary by platform, and Linux / Windows backends still need real-desktop validation.

Configurable permissions and risk review

Four permission modes: read-only / ask / auto / full-access. Calls that need review are handled using the selected mode, risk rules and model judgment; approvals, sandboxing and path grants depend on the mode and environment.

OS-level sandboxing

Sandboxed calls use sandbox-exec on macOS or bubblewrap on Linux: reads follow an allow-list, writes are scoped to the project and temp directories, and tool network access is off by default and granted per call. Outside paths and execution outside the sandbox are handled separately according to the permission mode; support varies on other platforms.

Secrets are redacted before the model sees them

Tool output, prompts, compaction summaries, memory and session files are scanned first; AWS/GCP/Azure/GitHub/GitLab/Slack/Stripe/OpenAI/Anthropic/JWT/PEM/DB URL rules, off / observe / redact / block modes, and an audit log with rule names and hashes only. Placeholders are restored only for file writes.

Built for long tasks

/compact summarization, context-budget tools, autonomous /goal loops, persistent memory and /dream consolidation. Sub-agents are dispatched only when you explicitly ask for them — fresh for an independent context or fork to inherit the conversation — and a stream cut mid-answer continues from where it stopped instead of losing the turn.

Sessions are assets

/resume past sessions, /fork from any message, /tree to browse branches, /rewind to roll back files and conversation together, /export for round-trip archives. Sessions are not tied to a vendor: switch gateways and /resume continues the same context on the current provider.

Workspace sessions have names and independent daemons

golder workspace opens the global default, and -s coding enters another set from any directory; new / attach / list / status / stop / rm all address a name. Each name is an independent daemon with its own config, state and logs; attaching, inspecting or stopping never requires the original project directory, and legacy project-scoped sessions remain reachable through their qualified selector.

Reads outside the workspace ask first

The read tools stay inside the workspace until you say otherwise — the dialog offers just this read, this session for that directory, or remembered (written to the authorization table, shown by /boundary). With nobody to ask (headless, a sub-agent) it fails closed. Full-access turns off review, not consent.

A first-class agent in tuios / herdr

Start it in a tuios window or a herdr pane and golder reports its own state: it shows up on the rail (working / waiting on you / done), approvals land in the Inbox, and a daemon restart brings the conversation back with golder --resume. Neither host changes; tuios gets one harness manifest from golder host-compat install, and herdr needs nothing.

Network is per call; proxies are selective

20 built-in gateways across four wire formats — OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini — plus any OpenAI-compatible endpoint. The network is off by default and granted per call: a call declares what it needs, auto grants it with the reviewer’s approval, and ask folds it into the same dialog as outside paths and sandbox escapes. There is no persistent network allow-list and no separate /network command. /proxy selects providers independently and can route Chromium panes with browser on; unselected routes go direct and ignore the shell’s HTTP_PROXY.

FAQ

Something else on your mind? Open an issue on GitHub. open an issue ↗

Is the macOS GUI signed and notarized?

Recent macOS GUI releases are Developer ID signed and Apple-notarized; older versions may not be. On first launch, macOS may ask to confirm opening an app downloaded from the internet. Accessibility and Screen Recording prompts may also appear. Download only from official Releases and check other security alerts on their own merits.

Does it need Node or any runtime?

Running Golder does not require Node or Python. The GUI and CLI are separate downloads; building from source requires Go, browser features can use a locally installed Chrome or Chromium, and the Linux GUI requires system graphics libraries.

Where does my code go?

Conversations and task context are sent to your configured model service. Browser, web and MCP tools may also send requests to the services you use. Sessions, memory and credentials are stored locally; what leaves your machine depends on your chosen models, tools and approvals.

Which models are supported?

20 built-in gateways (19 conversation gateways plus the typesafe decision model, which does not serve conversations). Sessions are not tied to a vendor: switch with /provider and keep going with /resume on the new one, and /provider default makes a gateway the default for new sessions. Reasoning levels run from off to max — or point it at a local Ollama.

Is it safe? Will it edit my files behind my back?

Three gates: a static hard-deny (sudo, rm -rf /, writes to ~/.ssh or credential material are refused outright — credentials are never grantable) → a per-call review (in auto every mutating call goes to the decision model, escalating to the session model when unsure: low risk runs, isolatable calls are contained, dangerous ones are denied, each with a one-line rationale) → the OS sandbox (read allow-list, writes limited to the project and temp dirs; the network is off by default and granted per call with the same capability review — there is no persistent network allow-list and no /network command). Switch to read-only to just watch.

Does the site work from mainland China?

golder itself supports per-provider proxies and connects directly to domestic models; its Chromium panes can share the same proxy with /proxy browser on (applied on the next browser launch). This site, however, is a free Cloudflare subdomain and may be unreachable on some networks — the GitHub repo and Releases are always the fallback.

Relation to pi?

golder is a Go re-implementation of pi, evolving independently under MIT.

How do I sign in to GitHub on Android?

Settings → GitHub defaults to GitHub login: open github.com/login/device, enter the device code, and the access token refreshes automatically. For least privilege, switch to Fine-grained PAT and grant Contents, Workflows and Actions read/write. Sign out removes local tokens only; to revoke the authorization itself, use Revoke access on GitHub.

How do I update?

Run golder update (self-update), or re-run the install script.