README.md

Latest commit

History

History
239 lines (169 loc) · 7.73 KB

README.md

File metadata and controls

239 lines (169 loc) · 7.73 KB
Raw

Codius

The open-source coding agent for Codius models and every provider you already use.

Build statusLicense

Codius CLI

Codius CLI is a terminal coding agent derived from OpenCode. It keeps OpenCode's agent loop, terminal UI, tools, sessions, MCP support, and broad provider ecosystem while making Codius the first-party default provider.

The executable is:

codius

The Agent Client Protocol entry point used by Codius App is:

codius acp

Product architecture

Codius Coding Plans
│
▼
Codius API — OpenAI-compatible inference
▲
│
Codius CLI — local coding agent and ACP server
▲
│
Codius App — visual workspace, browser, terminal, Git and worktrees

Codius CLI runs locally. File access, shell commands, Git operations, MCP tools, and agent sessions remain on the user's machine. Model requests are sent to the selected provider.

Codius endpoints

EnvironmentWebsiteOpenAI-compatible API
Developmenthttps://dev.codius.devhttps://devapi.codius.dev/v1
Productionhttps://codius.aihttps://api.codius.ai/v1

Development and prerelease builds default to the development environment. Stable releases default to production. Every endpoint can be overridden with environment variables.

Installation

Release installers will be published from this repository. During development, build from source:

git clone https://github.com/CodiusAI/codius-cli.git
cd codius-cli
git checkout dev
bun install
bun run --cwd packages/opencode build --single

The generated executable is named codius.

Once releases are enabled, the supported installer is:

curl -fsSL https://raw.githubusercontent.com/CodiusAI/codius-cli/dev/install | bash

Connect Codius

Create an API key in the Codius dashboard, then use either the interactive provider dialog or an environment variable.

Interactive

Start Codius:

codius

Open /connect, select Codius, and paste the API key. The credential is stored locally with the same protected credential store used by the upstream agent.

Headless, CI, or Codius App

export CODIUS_API_KEY="codius_..."
codius

PowerShell:

$env:CODIUS_API_KEY="codius_..."
codius

Automatic model catalog

At startup, Codius CLI downloads the current Codius provider block from the public integration endpoint:

/integrations/opencode/provider.json?variant=recommended

This means the CLI can receive newly qualified Codius models without a binary release. The provider block contains public model metadata only; it does not contain credentials.

The first fresh installation selects a Codius model by default. After a user explicitly selects another provider or model, that preference is retained.

Provider support

Codius is the default, not the only option. The fork preserves the upstream provider architecture, including API-key providers, subscription-backed providers, custom OpenAI-compatible endpoints, local models, and MCP integrations.

Examples include:

  • Codius
  • OpenAI and Codex
  • Anthropic
  • Google and Vertex AI
  • Amazon Bedrock
  • GitHub Copilot
  • OpenRouter
  • xAI
  • Mistral
  • Groq
  • custom OpenAI-compatible providers

Provider availability depends on the relevant account, API key, local runtime, and upstream terms.

Agent Client Protocol

Codius CLI includes an ACP server:

codius acp --cwd /path/to/project

Codius App launches this command and receives:

  • streamed assistant and reasoning events;
  • model and mode discovery;
  • session creation, resume, fork, and listing;
  • permission requests;
  • MCP server definitions;
  • tool and file-operation events.

The desktop application can therefore present Codius as a native provider while still using the mature OpenCode-derived agent runtime.

Configuration

Codius retains OpenCode-compatible project configuration so existing agent configurations remain usable. Internal compatibility names may continue to appear in configuration schemas while the fork is kept mergeable with upstream.

Useful Codius environment variables:

VariablePurpose
CODIUS_API_KEYCodius API key
CODIUS_ENVdevelopment or production
CODIUS_API_BASE_URLOverride the inference API base URL
CODIUS_WEB_BASE_URLOverride the website/control-plane base URL
CODIUS_PROVIDER_CONFIG_URLOverride the public provider-catalog endpoint
CODIUS_MODEL_CATALOG_VARIANTrecommended, all, or experimental
CODIUS_DEFAULT_MODELPrefer a specific Codius model on a fresh install
CODIUS_DISABLE_PROVIDER_BOOTSTRAPDisable automatic Codius provider injection
CODIUS_DEBUG_BOOTSTRAPPrint provider-bootstrap diagnostics

The following upstream-compatible variables remain supported where required by inherited internals and plugins:

OPENCODE_CONFIG
OPENCODE_CONFIG_CONTENT
OPENCODE_CONFIG_DIR
OPENCODE_PERMISSION

Development

Requirements:

  • Bun matching the version in the root package.json
  • Git
  • ripgrep

Common commands:

bun install
bun run dev
bun run typecheck
bun run --cwd packages/opencode test
bun run --cwd packages/opencode build --single

Test the Codius provider against development:

CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run dev

Test ACP locally:

CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run --cwd packages/opencode src/index.ts acp --cwd "$PWD"

Release and branding policy

Public artifacts from this fork must use:

  • product name: Codius CLI;
  • executable: codius;
  • repository: CodiusAI/codius-cli;
  • production website: https://codius.ai;
  • production API: https://api.codius.ai/v1;
  • development website: https://dev.codius.dev;
  • development API: https://devapi.codius.dev/v1.

Runware credentials and routing identifiers belong only in Codius server infrastructure. They must never be embedded in this repository, a release artifact, a desktop application, or a local configuration template.

Upstream and license

Codius CLI is based on OpenCode and preserves its MIT license and required notices. It is maintained independently by Prismosoft and is not produced by or affiliated with the OpenCode maintainers.

Generic fixes should be contributed upstream when practical so this fork remains maintainable. Codius-specific branding, model bootstrap, account integration, and release infrastructure stay in this repository.

Related projects

  • Codius — plans, dashboard, model catalog, metering, billing, and OpenAI-compatible API
  • Codius App — desktop workspace that launches codius acp
, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
README.md
Latest commit
History
History
239 lines (169 loc) · 7.73 KB
README.md
File metadata and controls
239 lines (169 loc) · 7.73 KB
Raw
Codius
The open-source coding agent for Codius models and every provider you already use.
Build statusLicense
Codius CLI
Codius CLI is a terminal coding agent derived from OpenCode. It keeps OpenCode's agent loop, terminal UI, tools, sessions, MCP support, and broad provider ecosystem while making Codius the first-party default provider.
The executable is:
codius
The Agent Client Protocol entry point used by Codius App is:
codius acp
Product architecture
Codius Coding Plans
│
▼
Codius API — OpenAI-compatible inference
▲
│
Codius CLI — local coding agent and ACP server
▲
│
Codius App — visual workspace, browser, terminal, Git and worktrees

Codius CLI runs locally. File access, shell commands, Git operations, MCP tools, and agent sessions remain on the user's machine. Model requests are sent to the selected provider.
Codius endpoints
EnvironmentWebsiteOpenAI-compatible API
Developmenthttps://dev.codius.devhttps://devapi.codius.dev/v1
Productionhttps://codius.aihttps://api.codius.ai/v1
Development and prerelease builds default to the development environment. Stable releases default to production. Every endpoint can be overridden with environment variables.
Installation
Release installers will be published from this repository. During development, build from source:
git clone https://github.com/CodiusAI/codius-cli.git
cd codius-cli
git checkout dev
bun install
bun run --cwd packages/opencode build --single
The generated executable is named codius.
Once releases are enabled, the supported installer is:
curl -fsSL https://raw.githubusercontent.com/CodiusAI/codius-cli/dev/install | bash
Connect Codius
Create an API key in the Codius dashboard, then use either the interactive provider dialog or an environment variable.
Interactive
Start Codius:
codius
Open /connect, select Codius, and paste the API key. The credential is stored locally with the same protected credential store used by the upstream agent.
Headless, CI, or Codius App
export CODIUS_API_KEY="codius_..."
codius
PowerShell:
$env:CODIUS_API_KEY="codius_..."
codius
Automatic model catalog
At startup, Codius CLI downloads the current Codius provider block from the public integration endpoint:
/integrations/opencode/provider.json?variant=recommended

This means the CLI can receive newly qualified Codius models without a binary release. The provider block contains public model metadata only; it does not contain credentials.
The first fresh installation selects a Codius model by default. After a user explicitly selects another provider or model, that preference is retained.
Provider support
Codius is the default, not the only option. The fork preserves the upstream provider architecture, including API-key providers, subscription-backed providers, custom OpenAI-compatible endpoints, local models, and MCP integrations.
Examples include:
  • Codius
  • OpenAI and Codex
  • Anthropic
  • Google and Vertex AI
  • Amazon Bedrock
  • GitHub Copilot
  • OpenRouter
  • xAI
  • Mistral
  • Groq
  • custom OpenAI-compatible providers
Provider availability depends on the relevant account, API key, local runtime, and upstream terms.
Agent Client Protocol
Codius CLI includes an ACP server:
codius acp --cwd /path/to/project
Codius App launches this command and receives:
  • streamed assistant and reasoning events;
  • model and mode discovery;
  • session creation, resume, fork, and listing;
  • permission requests;
  • MCP server definitions;
  • tool and file-operation events.
The desktop application can therefore present Codius as a native provider while still using the mature OpenCode-derived agent runtime.
Configuration
Codius retains OpenCode-compatible project configuration so existing agent configurations remain usable. Internal compatibility names may continue to appear in configuration schemas while the fork is kept mergeable with upstream.
Useful Codius environment variables:
VariablePurpose
CODIUS_API_KEYCodius API key
CODIUS_ENVdevelopment or production
CODIUS_API_BASE_URLOverride the inference API base URL
CODIUS_WEB_BASE_URLOverride the website/control-plane base URL
CODIUS_PROVIDER_CONFIG_URLOverride the public provider-catalog endpoint
CODIUS_MODEL_CATALOG_VARIANTrecommended, all, or experimental
CODIUS_DEFAULT_MODELPrefer a specific Codius model on a fresh install
CODIUS_DISABLE_PROVIDER_BOOTSTRAPDisable automatic Codius provider injection
CODIUS_DEBUG_BOOTSTRAPPrint provider-bootstrap diagnostics
The following upstream-compatible variables remain supported where required by inherited internals and plugins:
OPENCODE_CONFIG
OPENCODE_CONFIG_CONTENT
OPENCODE_CONFIG_DIR
OPENCODE_PERMISSION

Development
Requirements:
  • Bun matching the version in the root package.json
  • Git
  • ripgrep
Common commands:
bun install
bun run dev
bun run typecheck
bun run --cwd packages/opencode test
bun run --cwd packages/opencode build --single
Test the Codius provider against development:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run dev
Test ACP locally:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run --cwd packages/opencode src/index.ts acp --cwd "$PWD"
Release and branding policy
Public artifacts from this fork must use:
  • product name: Codius CLI;
  • executable: codius;
  • repository: CodiusAI/codius-cli;
  • production website: https://codius.ai;
  • production API: https://api.codius.ai/v1;
  • development website: https://dev.codius.dev;
  • development API: https://devapi.codius.dev/v1.
Runware credentials and routing identifiers belong only in Codius server infrastructure. They must never be embedded in this repository, a release artifact, a desktop application, or a local configuration template.
Upstream and license
Codius CLI is based on OpenCode and preserves its MIT license and required notices. It is maintained independently by Prismosoft and is not produced by or affiliated with the OpenCode maintainers.
Generic fixes should be contributed upstream when practical so this fork remains maintainable. Codius-specific branding, model bootstrap, account integration, and release infrastructure stay in this repository.
Related projects
  • Codius — plans, dashboard, model catalog, metering, billing, and OpenAI-compatible API
  • Codius App — desktop workspace that launches codius acp

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
README.md
Latest commit
History
History
239 lines (169 loc) · 7.73 KB
README.md
File metadata and controls
239 lines (169 loc) · 7.73 KB
Raw
Codius
The open-source coding agent for Codius models and every provider you already use.
Build statusLicense
Codius CLI
Codius CLI is a terminal coding agent derived from OpenCode. It keeps OpenCode's agent loop, terminal UI, tools, sessions, MCP support, and broad provider ecosystem while making Codius the first-party default provider.
The executable is:
codius
The Agent Client Protocol entry point used by Codius App is:
codius acp
Product architecture
Codius Coding Plans
│
▼
Codius API — OpenAI-compatible inference
▲
│
Codius CLI — local coding agent and ACP server
▲
│
Codius App — visual workspace, browser, terminal, Git and worktrees

Codius CLI runs locally. File access, shell commands, Git operations, MCP tools, and agent sessions remain on the user's machine. Model requests are sent to the selected provider.
Codius endpoints
EnvironmentWebsiteOpenAI-compatible API
Developmenthttps://dev.codius.devhttps://devapi.codius.dev/v1
Productionhttps://codius.aihttps://api.codius.ai/v1
Development and prerelease builds default to the development environment. Stable releases default to production. Every endpoint can be overridden with environment variables.
Installation
Release installers will be published from this repository. During development, build from source:
git clone https://github.com/CodiusAI/codius-cli.git
cd codius-cli
git checkout dev
bun install
bun run --cwd packages/opencode build --single
The generated executable is named codius.
Once releases are enabled, the supported installer is:
curl -fsSL https://raw.githubusercontent.com/CodiusAI/codius-cli/dev/install | bash
Connect Codius
Create an API key in the Codius dashboard, then use either the interactive provider dialog or an environment variable.
Interactive
Start Codius:
codius
Open /connect, select Codius, and paste the API key. The credential is stored locally with the same protected credential store used by the upstream agent.
Headless, CI, or Codius App
export CODIUS_API_KEY="codius_..."
codius
PowerShell:
$env:CODIUS_API_KEY="codius_..."
codius
Automatic model catalog
At startup, Codius CLI downloads the current Codius provider block from the public integration endpoint:
/integrations/opencode/provider.json?variant=recommended

This means the CLI can receive newly qualified Codius models without a binary release. The provider block contains public model metadata only; it does not contain credentials.
The first fresh installation selects a Codius model by default. After a user explicitly selects another provider or model, that preference is retained.
Provider support
Codius is the default, not the only option. The fork preserves the upstream provider architecture, including API-key providers, subscription-backed providers, custom OpenAI-compatible endpoints, local models, and MCP integrations.
Examples include:
  • Codius
  • OpenAI and Codex
  • Anthropic
  • Google and Vertex AI
  • Amazon Bedrock
  • GitHub Copilot
  • OpenRouter
  • xAI
  • Mistral
  • Groq
  • custom OpenAI-compatible providers
Provider availability depends on the relevant account, API key, local runtime, and upstream terms.
Agent Client Protocol
Codius CLI includes an ACP server:
codius acp --cwd /path/to/project
Codius App launches this command and receives:
  • streamed assistant and reasoning events;
  • model and mode discovery;
  • session creation, resume, fork, and listing;
  • permission requests;
  • MCP server definitions;
  • tool and file-operation events.
The desktop application can therefore present Codius as a native provider while still using the mature OpenCode-derived agent runtime.
Configuration
Codius retains OpenCode-compatible project configuration so existing agent configurations remain usable. Internal compatibility names may continue to appear in configuration schemas while the fork is kept mergeable with upstream.
Useful Codius environment variables:
VariablePurpose
CODIUS_API_KEYCodius API key
CODIUS_ENVdevelopment or production
CODIUS_API_BASE_URLOverride the inference API base URL
CODIUS_WEB_BASE_URLOverride the website/control-plane base URL
CODIUS_PROVIDER_CONFIG_URLOverride the public provider-catalog endpoint
CODIUS_MODEL_CATALOG_VARIANTrecommended, all, or experimental
CODIUS_DEFAULT_MODELPrefer a specific Codius model on a fresh install
CODIUS_DISABLE_PROVIDER_BOOTSTRAPDisable automatic Codius provider injection
CODIUS_DEBUG_BOOTSTRAPPrint provider-bootstrap diagnostics
The following upstream-compatible variables remain supported where required by inherited internals and plugins:
OPENCODE_CONFIG
OPENCODE_CONFIG_CONTENT
OPENCODE_CONFIG_DIR
OPENCODE_PERMISSION

Development
Requirements:
  • Bun matching the version in the root package.json
  • Git
  • ripgrep
Common commands:
bun install
bun run dev
bun run typecheck
bun run --cwd packages/opencode test
bun run --cwd packages/opencode build --single
Test the Codius provider against development:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run dev
Test ACP locally:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run --cwd packages/opencode src/index.ts acp --cwd "$PWD"
Release and branding policy
Public artifacts from this fork must use:
  • product name: Codius CLI;
  • executable: codius;
  • repository: CodiusAI/codius-cli;
  • production website: https://codius.ai;
  • production API: https://api.codius.ai/v1;
  • development website: https://dev.codius.dev;
  • development API: https://devapi.codius.dev/v1.
Runware credentials and routing identifiers belong only in Codius server infrastructure. They must never be embedded in this repository, a release artifact, a desktop application, or a local configuration template.
Upstream and license
Codius CLI is based on OpenCode and preserves its MIT license and required notices. It is maintained independently by Prismosoft and is not produced by or affiliated with the OpenCode maintainers.
Generic fixes should be contributed upstream when practical so this fork remains maintainable. Codius-specific branding, model bootstrap, account integration, and release infrastructure stay in this repository.
Related projects
  • Codius — plans, dashboard, model catalog, metering, billing, and OpenAI-compatible API
  • Codius App — desktop workspace that launches codius acp

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
README.md
Latest commit
History
History
239 lines (169 loc) · 7.73 KB
README.md
File metadata and controls
239 lines (169 loc) · 7.73 KB
Raw
Codius
The open-source coding agent for Codius models and every provider you already use.
Build statusLicense
Codius CLI
Codius CLI is a terminal coding agent derived from OpenCode. It keeps OpenCode's agent loop, terminal UI, tools, sessions, MCP support, and broad provider ecosystem while making Codius the first-party default provider.
The executable is:
codius
The Agent Client Protocol entry point used by Codius App is:
codius acp
Product architecture
Codius Coding Plans
│
▼
Codius API — OpenAI-compatible inference
▲
│
Codius CLI — local coding agent and ACP server
▲
│
Codius App — visual workspace, browser, terminal, Git and worktrees

Codius CLI runs locally. File access, shell commands, Git operations, MCP tools, and agent sessions remain on the user's machine. Model requests are sent to the selected provider.
Codius endpoints
EnvironmentWebsiteOpenAI-compatible API
Developmenthttps://dev.codius.devhttps://devapi.codius.dev/v1
Productionhttps://codius.aihttps://api.codius.ai/v1
Development and prerelease builds default to the development environment. Stable releases default to production. Every endpoint can be overridden with environment variables.
Installation
Release installers will be published from this repository. During development, build from source:
git clone https://github.com/CodiusAI/codius-cli.git
cd codius-cli
git checkout dev
bun install
bun run --cwd packages/opencode build --single
The generated executable is named codius.
Once releases are enabled, the supported installer is:
curl -fsSL https://raw.githubusercontent.com/CodiusAI/codius-cli/dev/install | bash
Connect Codius
Create an API key in the Codius dashboard, then use either the interactive provider dialog or an environment variable.
Interactive
Start Codius:
codius
Open /connect, select Codius, and paste the API key. The credential is stored locally with the same protected credential store used by the upstream agent.
Headless, CI, or Codius App
export CODIUS_API_KEY="codius_..."
codius
PowerShell:
$env:CODIUS_API_KEY="codius_..."
codius
Automatic model catalog
At startup, Codius CLI downloads the current Codius provider block from the public integration endpoint:
/integrations/opencode/provider.json?variant=recommended

This means the CLI can receive newly qualified Codius models without a binary release. The provider block contains public model metadata only; it does not contain credentials.
The first fresh installation selects a Codius model by default. After a user explicitly selects another provider or model, that preference is retained.
Provider support
Codius is the default, not the only option. The fork preserves the upstream provider architecture, including API-key providers, subscription-backed providers, custom OpenAI-compatible endpoints, local models, and MCP integrations.
Examples include:
  • Codius
  • OpenAI and Codex
  • Anthropic
  • Google and Vertex AI
  • Amazon Bedrock
  • GitHub Copilot
  • OpenRouter
  • xAI
  • Mistral
  • Groq
  • custom OpenAI-compatible providers
Provider availability depends on the relevant account, API key, local runtime, and upstream terms.
Agent Client Protocol
Codius CLI includes an ACP server:
codius acp --cwd /path/to/project
Codius App launches this command and receives:
  • streamed assistant and reasoning events;
  • model and mode discovery;
  • session creation, resume, fork, and listing;
  • permission requests;
  • MCP server definitions;
  • tool and file-operation events.
The desktop application can therefore present Codius as a native provider while still using the mature OpenCode-derived agent runtime.
Configuration
Codius retains OpenCode-compatible project configuration so existing agent configurations remain usable. Internal compatibility names may continue to appear in configuration schemas while the fork is kept mergeable with upstream.
Useful Codius environment variables:
VariablePurpose
CODIUS_API_KEYCodius API key
CODIUS_ENVdevelopment or production
CODIUS_API_BASE_URLOverride the inference API base URL
CODIUS_WEB_BASE_URLOverride the website/control-plane base URL
CODIUS_PROVIDER_CONFIG_URLOverride the public provider-catalog endpoint
CODIUS_MODEL_CATALOG_VARIANTrecommended, all, or experimental
CODIUS_DEFAULT_MODELPrefer a specific Codius model on a fresh install
CODIUS_DISABLE_PROVIDER_BOOTSTRAPDisable automatic Codius provider injection
CODIUS_DEBUG_BOOTSTRAPPrint provider-bootstrap diagnostics
The following upstream-compatible variables remain supported where required by inherited internals and plugins:
OPENCODE_CONFIG
OPENCODE_CONFIG_CONTENT
OPENCODE_CONFIG_DIR
OPENCODE_PERMISSION

Development
Requirements:
  • Bun matching the version in the root package.json
  • Git
  • ripgrep
Common commands:
bun install
bun run dev
bun run typecheck
bun run --cwd packages/opencode test
bun run --cwd packages/opencode build --single
Test the Codius provider against development:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run dev
Test ACP locally:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run --cwd packages/opencode src/index.ts acp --cwd "$PWD"
Release and branding policy
Public artifacts from this fork must use:
  • product name: Codius CLI;
  • executable: codius;
  • repository: CodiusAI/codius-cli;
  • production website: https://codius.ai;
  • production API: https://api.codius.ai/v1;
  • development website: https://dev.codius.dev;
  • development API: https://devapi.codius.dev/v1.
Runware credentials and routing identifiers belong only in Codius server infrastructure. They must never be embedded in this repository, a release artifact, a desktop application, or a local configuration template.
Upstream and license
Codius CLI is based on OpenCode and preserves its MIT license and required notices. It is maintained independently by Prismosoft and is not produced by or affiliated with the OpenCode maintainers.
Generic fixes should be contributed upstream when practical so this fork remains maintainable. Codius-specific branding, model bootstrap, account integration, and release infrastructure stay in this repository.
Related projects
  • Codius — plans, dashboard, model catalog, metering, billing, and OpenAI-compatible API
  • Codius App — desktop workspace that launches codius acp

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
README.md
Latest commit
History
History
239 lines (169 loc) · 7.73 KB
README.md
File metadata and controls
239 lines (169 loc) · 7.73 KB
Raw
Codius
The open-source coding agent for Codius models and every provider you already use.
Build statusLicense
Codius CLI
Codius CLI is a terminal coding agent derived from OpenCode. It keeps OpenCode's agent loop, terminal UI, tools, sessions, MCP support, and broad provider ecosystem while making Codius the first-party default provider.
The executable is:
codius
The Agent Client Protocol entry point used by Codius App is:
codius acp
Product architecture
Codius Coding Plans
│
▼
Codius API — OpenAI-compatible inference
▲
│
Codius CLI — local coding agent and ACP server
▲
│
Codius App — visual workspace, browser, terminal, Git and worktrees

Codius CLI runs locally. File access, shell commands, Git operations, MCP tools, and agent sessions remain on the user's machine. Model requests are sent to the selected provider.
Codius endpoints
EnvironmentWebsiteOpenAI-compatible API
Developmenthttps://dev.codius.devhttps://devapi.codius.dev/v1
Productionhttps://codius.aihttps://api.codius.ai/v1
Development and prerelease builds default to the development environment. Stable releases default to production. Every endpoint can be overridden with environment variables.
Installation
Release installers will be published from this repository. During development, build from source:
git clone https://github.com/CodiusAI/codius-cli.git
cd codius-cli
git checkout dev
bun install
bun run --cwd packages/opencode build --single
The generated executable is named codius.
Once releases are enabled, the supported installer is:
curl -fsSL https://raw.githubusercontent.com/CodiusAI/codius-cli/dev/install | bash
Connect Codius
Create an API key in the Codius dashboard, then use either the interactive provider dialog or an environment variable.
Interactive
Start Codius:
codius
Open /connect, select Codius, and paste the API key. The credential is stored locally with the same protected credential store used by the upstream agent.
Headless, CI, or Codius App
export CODIUS_API_KEY="codius_..."
codius
PowerShell:
$env:CODIUS_API_KEY="codius_..."
codius
Automatic model catalog
At startup, Codius CLI downloads the current Codius provider block from the public integration endpoint:
/integrations/opencode/provider.json?variant=recommended

This means the CLI can receive newly qualified Codius models without a binary release. The provider block contains public model metadata only; it does not contain credentials.
The first fresh installation selects a Codius model by default. After a user explicitly selects another provider or model, that preference is retained.
Provider support
Codius is the default, not the only option. The fork preserves the upstream provider architecture, including API-key providers, subscription-backed providers, custom OpenAI-compatible endpoints, local models, and MCP integrations.
Examples include:
  • Codius
  • OpenAI and Codex
  • Anthropic
  • Google and Vertex AI
  • Amazon Bedrock
  • GitHub Copilot
  • OpenRouter
  • xAI
  • Mistral
  • Groq
  • custom OpenAI-compatible providers
Provider availability depends on the relevant account, API key, local runtime, and upstream terms.
Agent Client Protocol
Codius CLI includes an ACP server:
codius acp --cwd /path/to/project
Codius App launches this command and receives:
  • streamed assistant and reasoning events;
  • model and mode discovery;
  • session creation, resume, fork, and listing;
  • permission requests;
  • MCP server definitions;
  • tool and file-operation events.
The desktop application can therefore present Codius as a native provider while still using the mature OpenCode-derived agent runtime.
Configuration
Codius retains OpenCode-compatible project configuration so existing agent configurations remain usable. Internal compatibility names may continue to appear in configuration schemas while the fork is kept mergeable with upstream.
Useful Codius environment variables:
VariablePurpose
CODIUS_API_KEYCodius API key
CODIUS_ENVdevelopment or production
CODIUS_API_BASE_URLOverride the inference API base URL
CODIUS_WEB_BASE_URLOverride the website/control-plane base URL
CODIUS_PROVIDER_CONFIG_URLOverride the public provider-catalog endpoint
CODIUS_MODEL_CATALOG_VARIANTrecommended, all, or experimental
CODIUS_DEFAULT_MODELPrefer a specific Codius model on a fresh install
CODIUS_DISABLE_PROVIDER_BOOTSTRAPDisable automatic Codius provider injection
CODIUS_DEBUG_BOOTSTRAPPrint provider-bootstrap diagnostics
The following upstream-compatible variables remain supported where required by inherited internals and plugins:
OPENCODE_CONFIG
OPENCODE_CONFIG_CONTENT
OPENCODE_CONFIG_DIR
OPENCODE_PERMISSION

Development
Requirements:
  • Bun matching the version in the root package.json
  • Git
  • ripgrep
Common commands:
bun install
bun run dev
bun run typecheck
bun run --cwd packages/opencode test
bun run --cwd packages/opencode build --single
Test the Codius provider against development:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run dev
Test ACP locally:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run --cwd packages/opencode src/index.ts acp --cwd "$PWD"
Release and branding policy
Public artifacts from this fork must use:
  • product name: Codius CLI;
  • executable: codius;
  • repository: CodiusAI/codius-cli;
  • production website: https://codius.ai;
  • production API: https://api.codius.ai/v1;
  • development website: https://dev.codius.dev;
  • development API: https://devapi.codius.dev/v1.
Runware credentials and routing identifiers belong only in Codius server infrastructure. They must never be embedded in this repository, a release artifact, a desktop application, or a local configuration template.
Upstream and license
Codius CLI is based on OpenCode and preserves its MIT license and required notices. It is maintained independently by Prismosoft and is not produced by or affiliated with the OpenCode maintainers.
Generic fixes should be contributed upstream when practical so this fork remains maintainable. Codius-specific branding, model bootstrap, account integration, and release infrastructure stay in this repository.
Related projects
  • Codius — plans, dashboard, model catalog, metering, billing, and OpenAI-compatible API
  • Codius App — desktop workspace that launches codius acp

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
README.md
Latest commit
History
History
239 lines (169 loc) · 7.73 KB
README.md
File metadata and controls
239 lines (169 loc) · 7.73 KB
Raw
Codius
The open-source coding agent for Codius models and every provider you already use.
Build statusLicense
Codius CLI
Codius CLI is a terminal coding agent derived from OpenCode. It keeps OpenCode's agent loop, terminal UI, tools, sessions, MCP support, and broad provider ecosystem while making Codius the first-party default provider.
The executable is:
codius
The Agent Client Protocol entry point used by Codius App is:
codius acp
Product architecture
Codius Coding Plans
│
▼
Codius API — OpenAI-compatible inference
▲
│
Codius CLI — local coding agent and ACP server
▲
│
Codius App — visual workspace, browser, terminal, Git and worktrees

Codius CLI runs locally. File access, shell commands, Git operations, MCP tools, and agent sessions remain on the user's machine. Model requests are sent to the selected provider.
Codius endpoints
EnvironmentWebsiteOpenAI-compatible API
Developmenthttps://dev.codius.devhttps://devapi.codius.dev/v1
Productionhttps://codius.aihttps://api.codius.ai/v1
Development and prerelease builds default to the development environment. Stable releases default to production. Every endpoint can be overridden with environment variables.
Installation
Release installers will be published from this repository. During development, build from source:
git clone https://github.com/CodiusAI/codius-cli.git
cd codius-cli
git checkout dev
bun install
bun run --cwd packages/opencode build --single
The generated executable is named codius.
Once releases are enabled, the supported installer is:
curl -fsSL https://raw.githubusercontent.com/CodiusAI/codius-cli/dev/install | bash
Connect Codius
Create an API key in the Codius dashboard, then use either the interactive provider dialog or an environment variable.
Interactive
Start Codius:
codius
Open /connect, select Codius, and paste the API key. The credential is stored locally with the same protected credential store used by the upstream agent.
Headless, CI, or Codius App
export CODIUS_API_KEY="codius_..."
codius
PowerShell:
$env:CODIUS_API_KEY="codius_..."
codius
Automatic model catalog
At startup, Codius CLI downloads the current Codius provider block from the public integration endpoint:
/integrations/opencode/provider.json?variant=recommended

This means the CLI can receive newly qualified Codius models without a binary release. The provider block contains public model metadata only; it does not contain credentials.
The first fresh installation selects a Codius model by default. After a user explicitly selects another provider or model, that preference is retained.
Provider support
Codius is the default, not the only option. The fork preserves the upstream provider architecture, including API-key providers, subscription-backed providers, custom OpenAI-compatible endpoints, local models, and MCP integrations.
Examples include:
  • Codius
  • OpenAI and Codex
  • Anthropic
  • Google and Vertex AI
  • Amazon Bedrock
  • GitHub Copilot
  • OpenRouter
  • xAI
  • Mistral
  • Groq
  • custom OpenAI-compatible providers
Provider availability depends on the relevant account, API key, local runtime, and upstream terms.
Agent Client Protocol
Codius CLI includes an ACP server:
codius acp --cwd /path/to/project
Codius App launches this command and receives:
  • streamed assistant and reasoning events;
  • model and mode discovery;
  • session creation, resume, fork, and listing;
  • permission requests;
  • MCP server definitions;
  • tool and file-operation events.
The desktop application can therefore present Codius as a native provider while still using the mature OpenCode-derived agent runtime.
Configuration
Codius retains OpenCode-compatible project configuration so existing agent configurations remain usable. Internal compatibility names may continue to appear in configuration schemas while the fork is kept mergeable with upstream.
Useful Codius environment variables:
VariablePurpose
CODIUS_API_KEYCodius API key
CODIUS_ENVdevelopment or production
CODIUS_API_BASE_URLOverride the inference API base URL
CODIUS_WEB_BASE_URLOverride the website/control-plane base URL
CODIUS_PROVIDER_CONFIG_URLOverride the public provider-catalog endpoint
CODIUS_MODEL_CATALOG_VARIANTrecommended, all, or experimental
CODIUS_DEFAULT_MODELPrefer a specific Codius model on a fresh install
CODIUS_DISABLE_PROVIDER_BOOTSTRAPDisable automatic Codius provider injection
CODIUS_DEBUG_BOOTSTRAPPrint provider-bootstrap diagnostics
The following upstream-compatible variables remain supported where required by inherited internals and plugins:
OPENCODE_CONFIG
OPENCODE_CONFIG_CONTENT
OPENCODE_CONFIG_DIR
OPENCODE_PERMISSION

Development
Requirements:
  • Bun matching the version in the root package.json
  • Git
  • ripgrep
Common commands:
bun install
bun run dev
bun run typecheck
bun run --cwd packages/opencode test
bun run --cwd packages/opencode build --single
Test the Codius provider against development:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run dev
Test ACP locally:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run --cwd packages/opencode src/index.ts acp --cwd "$PWD"
Release and branding policy
Public artifacts from this fork must use:
  • product name: Codius CLI;
  • executable: codius;
  • repository: CodiusAI/codius-cli;
  • production website: https://codius.ai;
  • production API: https://api.codius.ai/v1;
  • development website: https://dev.codius.dev;
  • development API: https://devapi.codius.dev/v1.
Runware credentials and routing identifiers belong only in Codius server infrastructure. They must never be embedded in this repository, a release artifact, a desktop application, or a local configuration template.
Upstream and license
Codius CLI is based on OpenCode and preserves its MIT license and required notices. It is maintained independently by Prismosoft and is not produced by or affiliated with the OpenCode maintainers.
Generic fixes should be contributed upstream when practical so this fork remains maintainable. Codius-specific branding, model bootstrap, account integration, and release infrastructure stay in this repository.
Related projects
  • Codius — plans, dashboard, model catalog, metering, billing, and OpenAI-compatible API
  • Codius App — desktop workspace that launches codius acp

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
README.md
Latest commit
History
History
239 lines (169 loc) · 7.73 KB
README.md
File metadata and controls
239 lines (169 loc) · 7.73 KB
Raw
Codius
The open-source coding agent for Codius models and every provider you already use.
Build statusLicense
Codius CLI
Codius CLI is a terminal coding agent derived from OpenCode. It keeps OpenCode's agent loop, terminal UI, tools, sessions, MCP support, and broad provider ecosystem while making Codius the first-party default provider.
The executable is:
codius
The Agent Client Protocol entry point used by Codius App is:
codius acp
Product architecture
Codius Coding Plans
│
▼
Codius API — OpenAI-compatible inference
▲
│
Codius CLI — local coding agent and ACP server
▲
│
Codius App — visual workspace, browser, terminal, Git and worktrees

Codius CLI runs locally. File access, shell commands, Git operations, MCP tools, and agent sessions remain on the user's machine. Model requests are sent to the selected provider.
Codius endpoints
EnvironmentWebsiteOpenAI-compatible API
Developmenthttps://dev.codius.devhttps://devapi.codius.dev/v1
Productionhttps://codius.aihttps://api.codius.ai/v1
Development and prerelease builds default to the development environment. Stable releases default to production. Every endpoint can be overridden with environment variables.
Installation
Release installers will be published from this repository. During development, build from source:
git clone https://github.com/CodiusAI/codius-cli.git
cd codius-cli
git checkout dev
bun install
bun run --cwd packages/opencode build --single
The generated executable is named codius.
Once releases are enabled, the supported installer is:
curl -fsSL https://raw.githubusercontent.com/CodiusAI/codius-cli/dev/install | bash
Connect Codius
Create an API key in the Codius dashboard, then use either the interactive provider dialog or an environment variable.
Interactive
Start Codius:
codius
Open /connect, select Codius, and paste the API key. The credential is stored locally with the same protected credential store used by the upstream agent.
Headless, CI, or Codius App
export CODIUS_API_KEY="codius_..."
codius
PowerShell:
$env:CODIUS_API_KEY="codius_..."
codius
Automatic model catalog
At startup, Codius CLI downloads the current Codius provider block from the public integration endpoint:
/integrations/opencode/provider.json?variant=recommended

This means the CLI can receive newly qualified Codius models without a binary release. The provider block contains public model metadata only; it does not contain credentials.
The first fresh installation selects a Codius model by default. After a user explicitly selects another provider or model, that preference is retained.
Provider support
Codius is the default, not the only option. The fork preserves the upstream provider architecture, including API-key providers, subscription-backed providers, custom OpenAI-compatible endpoints, local models, and MCP integrations.
Examples include:
  • Codius
  • OpenAI and Codex
  • Anthropic
  • Google and Vertex AI
  • Amazon Bedrock
  • GitHub Copilot
  • OpenRouter
  • xAI
  • Mistral
  • Groq
  • custom OpenAI-compatible providers
Provider availability depends on the relevant account, API key, local runtime, and upstream terms.
Agent Client Protocol
Codius CLI includes an ACP server:
codius acp --cwd /path/to/project
Codius App launches this command and receives:
  • streamed assistant and reasoning events;
  • model and mode discovery;
  • session creation, resume, fork, and listing;
  • permission requests;
  • MCP server definitions;
  • tool and file-operation events.
The desktop application can therefore present Codius as a native provider while still using the mature OpenCode-derived agent runtime.
Configuration
Codius retains OpenCode-compatible project configuration so existing agent configurations remain usable. Internal compatibility names may continue to appear in configuration schemas while the fork is kept mergeable with upstream.
Useful Codius environment variables:
VariablePurpose
CODIUS_API_KEYCodius API key
CODIUS_ENVdevelopment or production
CODIUS_API_BASE_URLOverride the inference API base URL
CODIUS_WEB_BASE_URLOverride the website/control-plane base URL
CODIUS_PROVIDER_CONFIG_URLOverride the public provider-catalog endpoint
CODIUS_MODEL_CATALOG_VARIANTrecommended, all, or experimental
CODIUS_DEFAULT_MODELPrefer a specific Codius model on a fresh install
CODIUS_DISABLE_PROVIDER_BOOTSTRAPDisable automatic Codius provider injection
CODIUS_DEBUG_BOOTSTRAPPrint provider-bootstrap diagnostics
The following upstream-compatible variables remain supported where required by inherited internals and plugins:
OPENCODE_CONFIG
OPENCODE_CONFIG_CONTENT
OPENCODE_CONFIG_DIR
OPENCODE_PERMISSION

Development
Requirements:
  • Bun matching the version in the root package.json
  • Git
  • ripgrep
Common commands:
bun install
bun run dev
bun run typecheck
bun run --cwd packages/opencode test
bun run --cwd packages/opencode build --single
Test the Codius provider against development:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run dev
Test ACP locally:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run --cwd packages/opencode src/index.ts acp --cwd "$PWD"
Release and branding policy
Public artifacts from this fork must use:
  • product name: Codius CLI;
  • executable: codius;
  • repository: CodiusAI/codius-cli;
  • production website: https://codius.ai;
  • production API: https://api.codius.ai/v1;
  • development website: https://dev.codius.dev;
  • development API: https://devapi.codius.dev/v1.
Runware credentials and routing identifiers belong only in Codius server infrastructure. They must never be embedded in this repository, a release artifact, a desktop application, or a local configuration template.
Upstream and license
Codius CLI is based on OpenCode and preserves its MIT license and required notices. It is maintained independently by Prismosoft and is not produced by or affiliated with the OpenCode maintainers.
Generic fixes should be contributed upstream when practical so this fork remains maintainable. Codius-specific branding, model bootstrap, account integration, and release infrastructure stay in this repository.
Related projects
  • Codius — plans, dashboard, model catalog, metering, billing, and OpenAI-compatible API
  • Codius App — desktop workspace that launches codius acp

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
README.md
Latest commit
History
History
239 lines (169 loc) · 7.73 KB
README.md
File metadata and controls
239 lines (169 loc) · 7.73 KB
Raw
Codius
The open-source coding agent for Codius models and every provider you already use.
Build statusLicense
Codius CLI
Codius CLI is a terminal coding agent derived from OpenCode. It keeps OpenCode's agent loop, terminal UI, tools, sessions, MCP support, and broad provider ecosystem while making Codius the first-party default provider.
The executable is:
codius
The Agent Client Protocol entry point used by Codius App is:
codius acp
Product architecture
Codius Coding Plans
│
▼
Codius API — OpenAI-compatible inference
▲
│
Codius CLI — local coding agent and ACP server
▲
│
Codius App — visual workspace, browser, terminal, Git and worktrees

Codius CLI runs locally. File access, shell commands, Git operations, MCP tools, and agent sessions remain on the user's machine. Model requests are sent to the selected provider.
Codius endpoints
EnvironmentWebsiteOpenAI-compatible API
Developmenthttps://dev.codius.devhttps://devapi.codius.dev/v1
Productionhttps://codius.aihttps://api.codius.ai/v1
Development and prerelease builds default to the development environment. Stable releases default to production. Every endpoint can be overridden with environment variables.
Installation
Release installers will be published from this repository. During development, build from source:
git clone https://github.com/CodiusAI/codius-cli.git
cd codius-cli
git checkout dev
bun install
bun run --cwd packages/opencode build --single
The generated executable is named codius.
Once releases are enabled, the supported installer is:
curl -fsSL https://raw.githubusercontent.com/CodiusAI/codius-cli/dev/install | bash
Connect Codius
Create an API key in the Codius dashboard, then use either the interactive provider dialog or an environment variable.
Interactive
Start Codius:
codius
Open /connect, select Codius, and paste the API key. The credential is stored locally with the same protected credential store used by the upstream agent.
Headless, CI, or Codius App
export CODIUS_API_KEY="codius_..."
codius
PowerShell:
$env:CODIUS_API_KEY="codius_..."
codius
Automatic model catalog
At startup, Codius CLI downloads the current Codius provider block from the public integration endpoint:
/integrations/opencode/provider.json?variant=recommended

This means the CLI can receive newly qualified Codius models without a binary release. The provider block contains public model metadata only; it does not contain credentials.
The first fresh installation selects a Codius model by default. After a user explicitly selects another provider or model, that preference is retained.
Provider support
Codius is the default, not the only option. The fork preserves the upstream provider architecture, including API-key providers, subscription-backed providers, custom OpenAI-compatible endpoints, local models, and MCP integrations.
Examples include:
  • Codius
  • OpenAI and Codex
  • Anthropic
  • Google and Vertex AI
  • Amazon Bedrock
  • GitHub Copilot
  • OpenRouter
  • xAI
  • Mistral
  • Groq
  • custom OpenAI-compatible providers
Provider availability depends on the relevant account, API key, local runtime, and upstream terms.
Agent Client Protocol
Codius CLI includes an ACP server:
codius acp --cwd /path/to/project
Codius App launches this command and receives:
  • streamed assistant and reasoning events;
  • model and mode discovery;
  • session creation, resume, fork, and listing;
  • permission requests;
  • MCP server definitions;
  • tool and file-operation events.
The desktop application can therefore present Codius as a native provider while still using the mature OpenCode-derived agent runtime.
Configuration
Codius retains OpenCode-compatible project configuration so existing agent configurations remain usable. Internal compatibility names may continue to appear in configuration schemas while the fork is kept mergeable with upstream.
Useful Codius environment variables:
VariablePurpose
CODIUS_API_KEYCodius API key
CODIUS_ENVdevelopment or production
CODIUS_API_BASE_URLOverride the inference API base URL
CODIUS_WEB_BASE_URLOverride the website/control-plane base URL
CODIUS_PROVIDER_CONFIG_URLOverride the public provider-catalog endpoint
CODIUS_MODEL_CATALOG_VARIANTrecommended, all, or experimental
CODIUS_DEFAULT_MODELPrefer a specific Codius model on a fresh install
CODIUS_DISABLE_PROVIDER_BOOTSTRAPDisable automatic Codius provider injection
CODIUS_DEBUG_BOOTSTRAPPrint provider-bootstrap diagnostics
The following upstream-compatible variables remain supported where required by inherited internals and plugins:
OPENCODE_CONFIG
OPENCODE_CONFIG_CONTENT
OPENCODE_CONFIG_DIR
OPENCODE_PERMISSION

Development
Requirements:
  • Bun matching the version in the root package.json
  • Git
  • ripgrep
Common commands:
bun install
bun run dev
bun run typecheck
bun run --cwd packages/opencode test
bun run --cwd packages/opencode build --single
Test the Codius provider against development:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run dev
Test ACP locally:
CODIUS_ENV=development \
CODIUS_API_KEY="codius_..." \
bun run --cwd packages/opencode src/index.ts acp --cwd "$PWD"
Release and branding policy
Public artifacts from this fork must use:
  • product name: Codius CLI;
  • executable: codius;
  • repository: CodiusAI/codius-cli;
  • production website: https://codius.ai;
  • production API: https://api.codius.ai/v1;
  • development website: https://dev.codius.dev;
  • development API: https://devapi.codius.dev/v1.
Runware credentials and routing identifiers belong only in Codius server infrastructure. They must never be embedded in this repository, a release artifact, a desktop application, or a local configuration template.
Upstream and license
Codius CLI is based on OpenCode and preserves its MIT license and required notices. It is maintained independently by Prismosoft and is not produced by or affiliated with the OpenCode maintainers.
Generic fixes should be contributed upstream when practical so this fork remains maintainable. Codius-specific branding, model bootstrap, account integration, and release infrastructure stay in this repository.
Related projects
  • Codius — plans, dashboard, model catalog, metering, billing, and OpenAI-compatible API
  • Codius App — desktop workspace that launches codius acp