owncode

---

OwnCode brings code editing, tool approvals, and parallel workers into one terminal interface. Choose your model, switch between Build and Plan, or let Witch coordinate specialist workers. Keep saved sessions and choose how OwnCode reduces their active context.

• Work visibly. Follow tool activity, inspect diffs, and approve requests above the message input.
• Choose your models. Connect a ChatGPT account, add a Claude API key, or configure a compatible endpoint.
• Coordinate workers. Open live subagent transcripts and send follow-ups to saved workers.
• Control context. Choose summary, Shake, Snapcompact, experimental Jev, or supported native compaction.
• Extend your workflow. Load skills, project instructions, MCP tools, and language servers.
• Recover a turn. Preview file changes before undoing or redoing a checkpoint.

Get started

Homebrew

brew install muratmirgun/tap/owncode
owncode

Install script

curl -fsSL https://raw.githubusercontent.com/muratmirgun/owncode/main/install -o /tmp/owncode-install
bash /tmp/owncode-install

The installer verifies SHA-256 checksums and installs into ~/.owncode/bin. Follow its PATH instruction, then run owncode. It leaves your shell configuration unchanged.

bash /tmp/owncode-install --version v0.1.0
bash /tmp/owncode-install --install-dir "$HOME/.local/bin"

Other installation methods

Method	Instructions
Release archive	Download a binary from Releases.
Debian / RPM	Download the matching .deb or .rpm package from the release.
Go	Run go install github.com/muratmirgun/owncode@latest with Go 1.27.1 or later.

Releases support macOS and Linux, with arm64 and x86_64 binaries. Git is required for repository operations. Windows binaries are not available.

Connect a model

Start OwnCode inside your project:

cd your-project
owncode

1. Enter /connect to connect a ChatGPT account or add a Claude API key.
2. Enter /models to select a model.
3. Write a request and press Enter.

OwnCode opens without a provider. Sending requires a configured model. For other endpoints, use the custom provider example.

Agents

Press Tab in the message field to switch profiles while agents are idle. Your draft stays intact.

Profile	Purpose
Build	Edit code and run tools through the approval flow.
Plan	Explore the project with read-only tools.
Witch	Coordinate specialist workers from the main conversation.
Custom	Define your own prompt, tools, model, and reasoning level.

Built-in Witch

OwnCode includes a preset based on Witch. Select it with Tab or /profiles. The main conversation becomes the controller.

Open Settings → Orchestration to set models and reasoning levels for its eight roles. Unset role models use the base chat model. Implementation workers can edit assigned files; research and review workers remain read-only.

A batch runs up to three children concurrently. Workers share the checkout. Open /agents to inspect activity, follow a transcript, or send a follow-up. See the Witch guide for roles and boundaries.

Context compaction

Choose Settings → Context → Method, then run /compact. One command uses your saved method.

Method	What it does
Summary	Creates a text summary with balanced, brief, or handoff modes. This is the default.
Shake	Archives attachments and eligible older, large tool results.
Snapcompact	Converts older text into image pages. Requires image support and remains experimental.
Jev	Uses Compact Engine to score and shorten eligible tool text.
Native	Uses a provider's native compaction path when the endpoint supports it.

Jev is experimental and requires a separate API key. It preserves attachments and protected content, so you do not need to run Shake first. If the engine cannot meet the reduction budget, OwnCode retains the original active history.

Automatic compaction defaults to 95% context usage. You can change the threshold in Settings. A compatible chat API does not automatically support native compaction. See compaction setup and limits, including the Jev configuration example.

Skills and project context

OwnCode reads ancestor AGENTS.md files and loads skill instructions on demand. Install repository skills globally:

owncode add @owner/repo
owncode add https://github.com/owner/repo --skill review-go

New installations use ~/.owncode/skills. Type @ to select installed skills or files. Skill selections insert @skill/name. OwnCode also discovers symlinked skills under ~/.agents/skills and ~/.agent/skills. Use /skills to inspect, update, or roll back a skill. The leading $skill-name syntax remains supported.

• Install skills from a local directory or a Git repository.
• Use project skills in .owncode/skills/ or .agents/skills/.
• Add MCP servers for external tools.
• Connect language servers for diagnostics, definitions, references, and symbols.

Optional skills.sh search requires a valid catalog API token. Authenticated search has not been live-verified. Git installation works without catalog access. See skills and server configuration.

Browser and computer control

Select optional backends in Settings → Automation:

• Embedded: headless automation using an installed Chromium browser.
• Chrome / Brave: visible, isolated browser sessions.
• CDP / Extension: connect an external browser or explicitly shared tabs.
• macOS: inspect and control native apps through system accessibility APIs.

These adapters need no paid automation service. The built-in browser client needs no Node.js or Python runtime. Both browser and computer access start disabled.

Run owncode browser setup to extract the optional Chrome/Brave extension. See the automation guide for pairing, permissions, screenshots, and current limits.

Keyboard controls

Key	Action
Ctrl+P / Ctrl+K / F1	Open the command palette
Tab	Switch agent profiles; complete an open suggestion
Ctrl+O / F2	Select a model
Alt+R / F4	Cycle supported reasoning levels
Ctrl+S / F3	Open saved sessions
↑ / ↓ at the input boundary	Recall sent prompts or restore your draft
Esc	Close a dialog or cancel active work

Use /settings, /models, /profiles, /skills, /agents, or /help if your terminal intercepts a shortcut. Mac keyboards may require Fn for function keys.

Execution controls

• /fast on requests priority processing for OpenAI and ChatGPT calls, including supported workers. /fast off selects standard processing.
• /yolo on approves tool permission requests automatically, including worker requests. /yolo off restores normal permission checks.
• /fast and /yolo without an argument toggle their modes. The input area shows active modes. Both reset on restart.

Fast mode preserves the model and reasoning level. Provider access and higher usage rates can apply. OwnCode does not send priority fields to other providers. See OpenAI fast mode. YOLO changes permission prompts only. Plan restrictions, worker ownership rules, and explicit user questions remain active. Turning YOLO off retains approvals that you granted separately with Allow for session.

While workers stream, Σ ≈… TPS shows the combined live rate for the current conversation and its workers. The rate excludes finished workers and unrelated conversations. Live counts estimate visible text, reasoning, and tool arguments. Provider token counts replace estimates at completion when available. Hidden reasoning can make live rates differ from provider totals.

Each worker has its own shell. Commands retain shell state within that worker's active task. Commands from different workers can overlap. Cancellation stops that worker's shell; its next command starts a fresh shell.

Configuration

Keep model definitions and keys in ~/.owncode.json. Project files can override global settings. Remove duplicate project entries when you want global values to apply. Managed provider connections use a separate credentials file in the operating system's user configuration directory.

OwnCode uses its own configuration schema. It does not directly load current OpenCode configuration files or npm provider plugins. See the configuration guide for search order, examples, and storage locations.

Questions

Is this the same project as OpenCode?

OwnCode is an independent fork of the archived Go OpenCode project, which continued as Crush. It is separate from the current OpenCode application. The original MIT license and attribution remain intact.

Can I resume a conversation?

Yes. OwnCode prints a resume command when you exit a saved chat:

owncode -s SESSION_ID

Run it from the same project directory and use the same data directory. You can also select saved conversations through /sessions.

Can I use OwnCode in scripts?

owncode -p "Explain this repository"
owncode -p "List the main packages" -f json

Non-interactive mode automatically approves tool permissions for its session. See scripting before using it in automation.

How stable is it?

OwnCode is experimental. Provider behavior depends on the model and endpoint. Workers share files, recovery has limits, and some compaction methods require specific provider capabilities. The user guide describes these boundaries.

Development

git clone https://github.com/muratmirgun/owncode.git
cd owncode
go build -o bin/owncode .
go test ./...
go vet ./...
./bin/owncode

Use Go 1.27.1 or later and Git. See development checks, the roadmap, and release instructions.

Contributions are welcome. Keep changes focused and describe the checks you ran. For interface changes, include a screenshot and terminal dimensions.

License and credits

OwnCode uses the MIT License. Thanks to the original OpenCode contributors and the Charm community for the foundation. See the original credits and Witch license.