Back to the Finder

Jcode

Open-source desktop app for Mac, Windows and Linux. Agents run on your computer, on your own server or in the vendor's cloud.

Product websitejcode.sh Compare with others Missing or wrong data?

Jcode product interface, supplied by its publisher
Desktop app
Mac, Windows and Linux
Browser
Not listed
Phone
IPhone
Command line
Yes
Agents
No
Your subscription
Works with your own plan
Agents run
On your computer, on your own server and in the vendor's cloud
Laptop closed
Keeps going
Isolation
Worktree and VM
Parallel agents
Yes
Scheduled runs
Yes
Coordinator agent
Yes
Built-in issues
Yes
Pull requests
Not listed
Review screen
Yes
Team
Not listed
Self-hosting
Yes
Licence
MIT
Price from
Free
How it charges
Free plan, subscription, usage-based, per machine or compute and bring your own key
Paid plans from
$10 or less/month

Receipts

Checked
· oldest answer 2026-11-08
Findings
41 published · 34 cross-checked by a second agent · read them all
Sources
49 public pages on 2 sites: jcode.sh, github.com
Screenshot
jcode.sh, retrieved · first party marketing · shows appearance, not capability
Method
Same rules for all 103 researched ADEs. How we check · Report wrong data

What it does

Where you use it

Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

Source and scope for Where you use it

Agents it runs

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

Source and scope for Agents it runs

Accounts and subscriptions

Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.

Source and scope for Accounts and subscriptions

Where agents run

The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket. Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

Source and scope for Where agents run

How work is kept apart

Swarm coordination supports optional Git worktrees and worktree manager roles for separate code work and later integration. These are checkout boundaries, not hostile-code sandboxes. The optional Jcode Cloud service offers cloud-agent virtual machines.

Source and scope for How work is kept apart

Parallel work

Multiple agents can work concurrently in the same repository; the server manages messaging, completion status and file-change notifications. Actual concurrency and performance benchmarks were not rerun.

Source and scope for Parallel work

Scheduled runs

Ambient mode is implemented but disabled by default. It runs one proactive background agent, self-schedules wakeups and prioritizes interactive sessions; later design ideas in the document are not all shipped.

Source and scope for Scheduled runs

Git and pull requests

The inspected public Jcode CLI/desktop implementation has no dedicated native PR creation or management operation; agents can use generic shell/MCP tools. The optional closed Jcode Cloud service does not have enough public workflow detail to establish a product-wide PR value.

Source and scope for Git and pull requests

Licence and source

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Source and scope for Licence and source

Price

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

Source and scope for Price

JSON for agentsMarkdown for agents

Report wrong dataSuggest a missing ADE

Typed filters

Every value links to its receipt below. Read plan and surface restrictions before using a filter to decide.

Typed filter values
FilterValue
Desktop OS: macOSYes
Desktop OS: WindowsYes
Desktop OS: LinuxYes
Web clientUnknown
Phone access: Native iOSYes
Phone access: Native AndroidNo
Phone access: Phone browserUnknown
CLIYes cross-checked
Coding agents: Claude CodeNo
Coding agents: CodexNo
Coding agents: Cursor AgentNo
Coding agents: Gemini CLINo
Coding agents: OpenCodeNo
Coding agents: PiNo
Coding agents: GrokNo
Coding agents: AiderNo
Coding agents: AntigravityNo
Use my subscriptionYes cross-checked
Where agents run: On your computerYes cross-checked
Where agents run: On your own serverYes cross-checked
Where agents run: In the vendor's cloudYes cross-checked
Workspace isolation: Git worktreeYes
Workspace isolation: ContainerUnknown
Workspace isolation: VM or microVMYes
Parallel runsYes cross-checked
CoordinatorYes cross-checked
Native issue trackingYes cross-checked
Unattended triggersYes cross-checked
Shared promptingUnknown
Team rolesUnknown
SSOUnknown
Pull request workflowUnknown
Review interfaceYes cross-checked
Product license: Apache-2.0No. MIT cross-checked
Product license: MITYes. MIT cross-checked
Product license: GPL-3.0No. MIT cross-checked
Product license: GPL-3.0-or-laterNo. MIT cross-checked
Product license: AGPL-3.0No. MIT cross-checked
Product license: AGPL-3.0-or-laterNo. MIT cross-checked
Product license: Elastic License 2.0No. MIT cross-checked
Product license: Custom termsNo. MIT cross-checked
Product license: ProprietaryNo. MIT cross-checked
Self-hostingYes cross-checked
Telemetry opt-outYes cross-checked
Free accessYes cross-checked
Starting price: FreeYes. Free cross-checked
Starting price: Up to $20/monthNo. Free cross-checked
Starting price: $21–40/monthNo. Free cross-checked
Starting price: $41–100/monthNo. Free cross-checked
Starting price: Over $100/monthNo. Free cross-checked
Starting price: Contact for pricingNo. Free cross-checked
Pricing model: Free, no paid planNo
Pricing model: Free planYes cross-checked
Pricing model: SubscriptionYes
Pricing model: Per seatNo
Pricing model: Usage-basedYes
Pricing model: Per machine or computeYes
Pricing model: Bring your own keyYes cross-checked
Pricing model: One-time purchaseNo
Paid plans from: No paid planNo. $10 or less/month
Paid plans from: $10 or less/monthYes. $10 or less/month
Paid plans from: $11–20/monthNo. $10 or less/month
Paid plans from: $21–40/monthNo. $10 or less/month
Paid plans from: $41–100/monthNo. $10 or less/month
Paid plans from: Over $100/monthNo. $10 or less/month
Paid plans from: Contact salesNo. $10 or less/month
Lifecycle status: ActiveUnknown
Lifecycle status: SunsettingUnknown
Keeps going with laptop closedYes cross-checked
Open-source licenseYes. MIT cross-checked
Any desktop appYes
Paid plan up to $20/monthYes. $10 or less/month
Paid plan up to $40/monthYes. $10 or less/month
Any phone clientYes

Filter receipts

Desktop OS: macOS: Yes

Desktop OS: macOS

Typed value: Yes.

Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

  • Desktop os: Jcode Desktop ships a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP.
  • Cli: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.
  • Task actions: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.
  • Notifications: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.
  • Cross device continuity: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.
  • The scoped first-party source pass does not establish browser, mobile_browser, editor_extensions. No hands-on scenario was run.
  1. Jcode: Install; First run

    Finding: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.

  2. Jcode: Download

    Finding: Jcode Desktop has a universal macOS DMG requiring macOS 13 or newer, Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP. Linux packages are not repository-signed and the Windows app is not code-signed. The page does not label the desktop app beta.

  3. Jcode: Mobile continuation

    Finding: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.

Desktop OS: Windows: Yes

Desktop OS: Windows

Typed value: Yes.

Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

  • Desktop os: Jcode Desktop ships a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP.
  • Cli: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.
  • Task actions: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.
  • Notifications: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.
  • Cross device continuity: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.
  • The scoped first-party source pass does not establish browser, mobile_browser, editor_extensions. No hands-on scenario was run.
  1. Jcode: Install; First run

    Finding: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.

  2. Jcode: Download

    Finding: Jcode Desktop has a universal macOS DMG requiring macOS 13 or newer, Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP. Linux packages are not repository-signed and the Windows app is not code-signed. The page does not label the desktop app beta.

  3. Jcode: Mobile continuation

    Finding: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.

Desktop OS: Linux: Yes

Desktop OS: Linux

Typed value: Yes.

Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

  • Desktop os: Jcode Desktop ships a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP.
  • Cli: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.
  • Task actions: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.
  • Notifications: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.
  • Cross device continuity: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.
  • The scoped first-party source pass does not establish browser, mobile_browser, editor_extensions. No hands-on scenario was run.
  1. Jcode: Install; First run

    Finding: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.

  2. Jcode: Download

    Finding: Jcode Desktop has a universal macOS DMG requiring macOS 13 or newer, Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP. Linux packages are not repository-signed and the Windows app is not code-signed. The page does not label the desktop app beta.

  3. Jcode: Mobile continuation

    Finding: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.

Phone access: Native iOS: Yes

Phone access: Native iOS

Typed value: Yes.

Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

  • Mobile apps: The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.
  • The scoped first-party source pass does not establish browser, mobile_browser, editor_extensions. No hands-on scenario was run.
  1. Jcode Mobile public beta

    Finding: Jcode Mobile is a native iPhone client with a public TestFlight join link at testflight.apple.com/join/ZHSYwcyf. It needs a Jcode account and supports agent messages and session continuation. The published client is iOS; no Android distribution is listed.

Phone access: Native Android: No

Phone access: Native Android

Typed value: No.

Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

  • Mobile apps: The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.
  • The scoped first-party source pass does not establish browser, mobile_browser, editor_extensions. No hands-on scenario was run.
  1. Jcode Mobile public beta

    Finding: Jcode Mobile is a native iPhone client with a public TestFlight join link at testflight.apple.com/join/ZHSYwcyf. It needs a Jcode account and supports agent messages and session continuation. The published client is iOS; no Android distribution is listed.

CLI: Yes cross-checked

CLI

Typed value: Yes.

The TypeScript SDK launches a private Jcode process or attaches through api-bridge to a local or forwarded remote daemon, with session and streaming operations.

  • Cli: The TypeScript SDK launches a private Jcode process or attaches through api-bridge to a local or forwarded remote daemon, with session and streaming operations.
  • Api: The TypeScript SDK launches a private Jcode process or attaches through api-bridge to a local or forwarded remote daemon, with session and streaming operations.
  • Sdk: The TypeScript SDK launches a private Jcode process or attaches through api-bridge to a local or forwarded remote daemon, with session and streaming operations.
  • Operations: The TypeScript SDK launches a private Jcode process or attaches through api-bridge to a local or forwarded remote daemon, with session and streaming operations.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: TypeScript SDK

    Finding: The TypeScript SDK launches a private Jcode process or attaches through api-bridge to a local or forwarded remote daemon, with session and streaming operations.

Coding agents: Claude Code: No

Coding agents: Claude Code

Typed value: No.

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • Harnesses: Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.
  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

Coding agents: Codex: No

Coding agents: Codex

Typed value: No.

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • Harnesses: Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.
  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

Coding agents: Cursor Agent: No

Coding agents: Cursor Agent

Typed value: No.

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • Harnesses: Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.
  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

Coding agents: Gemini CLI: No

Coding agents: Gemini CLI

Typed value: No.

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • Harnesses: Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.
  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

Coding agents: OpenCode: No

Coding agents: OpenCode

Typed value: No.

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • Harnesses: Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.
  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

Coding agents: Pi: No

Coding agents: Pi

Typed value: No.

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • Harnesses: Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.
  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

Coding agents: Grok: No

Coding agents: Grok

Typed value: No.

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • Harnesses: Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.
  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

Coding agents: Aider: No

Coding agents: Aider

Typed value: No.

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • Harnesses: Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.
  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

Coding agents: Antigravity: No

Coding agents: Antigravity

Typed value: No.

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • Harnesses: Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.
  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

Use my subscription: Yes cross-checked

Use my subscription

Typed value: Yes.

Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.

  • Agent subscriptions: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.
  • Api accounts: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.
  • Local models: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.
  • Account switching: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Providers and login; Headless logins

    Finding: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.

Where agents run: On your computer: Yes cross-checked

Where agents run: On your computer

Typed value: Yes.

The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket. Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

  • Local: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Byo remote: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Self hosted: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Managed cloud: Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.
  • Client disconnect: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Other device continuation: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Remote use

    Finding: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.

  2. Jcode: Cloud session CLI

    Finding: Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

Where agents run: On your own server: Yes cross-checked

Where agents run: On your own server

Typed value: Yes.

The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket. Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

  • Local: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Byo remote: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Self hosted: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Managed cloud: Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.
  • Client disconnect: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Other device continuation: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Remote use

    Finding: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.

  2. Jcode: Cloud session CLI

    Finding: Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

Where agents run: In the vendor's cloud: Yes cross-checked

Where agents run: In the vendor's cloud

Typed value: Yes.

The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket. Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

  • Local: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Byo remote: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Self hosted: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Managed cloud: Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.
  • Client disconnect: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Other device continuation: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Remote use

    Finding: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.

  2. Jcode: Cloud session CLI

    Finding: Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

Workspace isolation: Git worktree: Yes

Workspace isolation: Git worktree

Typed value: Yes.

Swarm coordination supports optional Git worktrees and worktree manager roles for separate code work and later integration. These are checkout boundaries, not hostile-code sandboxes. The optional Jcode Cloud service offers cloud-agent virtual machines.

  • Worktree: Swarm coordination supports optional Git worktrees and worktree manager roles for separate code work and later integration. These are checkout boundaries, not hostile-code sandboxes.
  • Code separation: Swarm coordination supports optional Git worktrees and worktree manager roles for separate code work and later integration. These are checkout boundaries, not hostile-code sandboxes.
  • The scoped first-party source pass does not establish checkout, branch, container, os_sandbox, filesystem, process, network, secrets, security_boundary. No hands-on scenario was run.
  1. Jcode: Swarm Architecture; Worktree Manager

    Finding: Swarm coordination supports optional Git worktrees and worktree manager roles for separate code work and later integration. These are checkout boundaries, not hostile-code sandboxes.

Workspace isolation: VM or microVM: Yes

Workspace isolation: VM or microVM

Typed value: Yes.

Swarm coordination supports optional Git worktrees and worktree manager roles for separate code work and later integration. These are checkout boundaries, not hostile-code sandboxes. The optional Jcode Cloud service offers cloud-agent virtual machines.

  • Vm: The optional Jcode Cloud service offers cloud-agent virtual machines.
  • The scoped first-party source pass does not establish checkout, branch, container, os_sandbox, filesystem, process, network, secrets, security_boundary. No hands-on scenario was run.
  1. Jcode hosted pricing and VM execution

    Finding: The pricing page explicitly offers cloud agent VMs, with 50 Jcode Cloud machine hours per $10 monthly plan. Paid model overage uses provider API prices; local MIT software and user-supplied subscriptions remain separate.

Parallel runs: Yes cross-checked

Parallel runs

Typed value: Yes.

Multiple agents can work concurrently in the same repository; the server manages messaging, completion status and file-change notifications. Actual concurrency and performance benchmarks were not rerun.

  • Concurrent sessions: Multiple agents can work concurrently in the same repository; the server manages messaging, completion status and file-change notifications. Actual concurrency and performance benchmarks were not rerun.
  • Concurrent tasks: Multiple agents can work concurrently in the same repository; the server manages messaging, completion status and file-change notifications. Actual concurrency and performance benchmarks were not rerun.
  • Status visibility: Multiple agents can work concurrently in the same repository; the server manages messaging, completion status and file-change notifications. Actual concurrency and performance benchmarks were not rerun.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Swarm

    Finding: Multiple agents can work concurrently in the same repository; the server manages messaging, completion status and file-change notifications. Actual concurrency and performance benchmarks were not rerun.

Coordinator: Yes cross-checked

Coordinator

Typed value: Yes.

Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.

  • Roles: Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.
  • Messages: Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.
  • Results return: Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.
  • Orchestration owner: Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.
  • Activation: Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.
  • Live progress: Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Swarm

    Finding: Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.

Native issue tracking: Yes cross-checked

Native issue tracking

Typed value: Yes.

Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.

  • Create: Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.
  • Edit: Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.
  • Prioritize: Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.
  • Project epic views: Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.
  • Metadata: Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.
  • Durable states: Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Todo planning hierarchy

    Finding: Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.

Unattended triggers: Yes cross-checked

Unattended triggers

Typed value: Yes.

Ambient mode is implemented but disabled by default. It runs one proactive background agent, self-schedules wakeups and prioritizes interactive sessions; later design ideas in the document are not all shipped.

  • Schedules: Ambient mode is implemented but disabled by default. It runs one proactive background agent, self-schedules wakeups and prioritizes interactive sessions; later design ideas in the document are not all shipped.
  • Scheduler location: Ambient mode is implemented but disabled by default. It runs one proactive background agent, self-schedules wakeups and prioritizes interactive sessions; later design ideas in the document are not all shipped.
  • Client independence: Ambient mode is implemented but disabled by default. It runs one proactive background agent, self-schedules wakeups and prioritizes interactive sessions; later design ideas in the document are not all shipped.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Status; Key design decisions

    Finding: Ambient mode is implemented but disabled by default. It runs one proactive background agent, self-schedules wakeups and prioritizes interactive sessions; later design ideas in the document are not all shipped.

Review interface: Yes cross-checked

Review interface

Typed value: Yes.

Jcode Desktop renders file diffs beside live sessions, and the TUI /diff command cycles the diff display mode. No guided human review measurement was run.

  • Change understanding: Desktop renders file diffs beside live sessions; the TUI /diff command cycles the diff display mode.
  • Evidence navigation: Desktop shows diffs, diagrams, images and tool calls beside each session.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Diffs, rendered

    Finding: Jcode Desktop renders file diffs, Mermaid diagrams, inline images and compact tool calls beside live agent sessions. No guided human review measurement was run.

Product license: Apache-2.0: No. MIT cross-checked

Product license: Apache-2.0

Typed value: No. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Product license: MIT: Yes. MIT cross-checked

Product license: MIT

Typed value: Yes. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Product license: GPL-3.0: No. MIT cross-checked

Product license: GPL-3.0

Typed value: No. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Product license: GPL-3.0-or-later: No. MIT cross-checked

Product license: GPL-3.0-or-later

Typed value: No. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Product license: AGPL-3.0: No. MIT cross-checked

Product license: AGPL-3.0

Typed value: No. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Product license: AGPL-3.0-or-later: No. MIT cross-checked

Product license: AGPL-3.0-or-later

Typed value: No. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Product license: Elastic License 2.0: No. MIT cross-checked

Product license: Elastic License 2.0

Typed value: No. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Product license: Custom terms: No. MIT cross-checked

Product license: Custom terms

Typed value: No. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Product license: Proprietary: No. MIT cross-checked

Product license: Proprietary

Typed value: No. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Self-hosting: Yes cross-checked

Self-hosting

Typed value: Yes.

The Jcode daemon, TUI and tools can run on a user-controlled machine or SSH host, with direct model credentials or local servers. Optional Jcode Cloud is not required for local use.

  • Self hosting: The Jcode daemon, TUI and tools can run on a user-controlled machine or SSH host, with direct model credentials or local servers. Optional Jcode Cloud is not required for local use.
  • Vendor dependencies: The Jcode daemon, TUI and tools can run on a user-controlled machine or SSH host, with direct model credentials or local servers. Optional Jcode Cloud is not required for local use.
  • Account independence: The Jcode daemon, TUI and tools can run on a user-controlled machine or SSH host, with direct model credentials or local servers. Optional Jcode Cloud is not required for local use.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: From source; Remote use

    Finding: The Jcode daemon, TUI and tools can run on a user-controlled machine or SSH host, with direct model credentials or local servers. Optional Jcode Cloud is not required for local use.

Telemetry opt-out: Yes cross-checked

Telemetry opt-out

Typed value: Yes.

Default usage telemetry may include provider OAuth email, installation ID and numeric/categorical usage. Full transcript sharing is separately opt-in. jcode telemetry disable, JCODE_NO_TELEMETRY=1, DO_NOT_TRACK=1 or a no_telemetry file disables telemetry.

  • Telemetry disclosure: Default usage telemetry may include provider OAuth email, installation ID and numeric/categorical usage. Full transcript sharing is separately opt-in. jcode telemetry disable, JCODE_NO_TELEMETRY=1, DO_NOT_TRACK=1 or a no_telemetry file disables telemetry.
  • Telemetry defaults: Default usage telemetry may include provider OAuth email, installation ID and numeric/categorical usage. Full transcript sharing is separately opt-in. jcode telemetry disable, JCODE_NO_TELEMETRY=1, DO_NOT_TRACK=1 or a no_telemetry file disables telemetry.
  • Telemetry controls: Default usage telemetry may include provider OAuth email, installation ID and numeric/categorical usage. Full transcript sharing is separately opt-in. jcode telemetry disable, JCODE_NO_TELEMETRY=1, DO_NOT_TRACK=1 or a no_telemetry file disables telemetry.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Ordinary telemetry; How to Opt Out

    Finding: Default usage telemetry may include provider OAuth email, installation ID and numeric/categorical usage. Full transcript sharing is separately opt-in. jcode telemetry disable, JCODE_NO_TELEMETRY=1, DO_NOT_TRACK=1 or a no_telemetry file disables telemetry.

Free access: Yes cross-checked

Free access

Typed value: Yes.

The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

  • Ongoing free: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Self host cost: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

Starting price: Free: Yes. Free cross-checked

Starting price: Free

Typed value: Yes. Free.

The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

  • Ongoing free: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Self host cost: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

Starting price: Up to $20/month: No. Free cross-checked

Starting price: Up to $20/month

Typed value: No. Free.

The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

  • Ongoing free: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Self host cost: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

Starting price: $21–40/month: No. Free cross-checked

Starting price: $21–40/month

Typed value: No. Free.

The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

  • Ongoing free: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Self host cost: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

Starting price: $41–100/month: No. Free cross-checked

Starting price: $41–100/month

Typed value: No. Free.

The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

  • Ongoing free: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Self host cost: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

Starting price: Over $100/month: No. Free cross-checked

Starting price: Over $100/month

Typed value: No. Free.

The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

  • Ongoing free: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Self host cost: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

Starting price: Contact for pricing: No. Free cross-checked

Starting price: Contact for pricing

Typed value: No. Free.

The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

  • Ongoing free: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Self host cost: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

Pricing model: Free, no paid plan: No

Pricing model: Free, no paid plan

Typed value: No.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Pricing model: Free plan: Yes cross-checked

Pricing model: Free plan

Typed value: Yes.

The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

  • Ongoing free: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Self host cost: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

Pricing model: Subscription: Yes

Pricing model: Subscription

Typed value: Yes.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Pricing model: Per seat: No

Pricing model: Per seat

Typed value: No.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Pricing model: Usage-based: Yes

Pricing model: Usage-based

Typed value: Yes.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Pricing model: Per machine or compute: Yes

Pricing model: Per machine or compute

Typed value: Yes.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Compute cost: Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode hosted pricing and VM execution

    Finding: The pricing page explicitly offers cloud agent VMs, with 50 Jcode Cloud machine hours per $10 monthly plan. Paid model overage uses provider API prices; local MIT software and user-supplied subscriptions remain separate.

Pricing model: Bring your own key: Yes cross-checked

Pricing model: Bring your own key

Typed value: Yes.

Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.

  • Agent subscriptions: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.
  • Api accounts: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.
  • Local models: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.
  • Account switching: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Providers and login; Headless logins

    Finding: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.

Pricing model: One-time purchase: No

Pricing model: One-time purchase

Typed value: No.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Paid plans from: No paid plan: No. $10 or less/month

Paid plans from: No paid plan

Typed value: No. $10 or less/month.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Paid plans from: $10 or less/month: Yes. $10 or less/month

Paid plans from: $10 or less/month

Typed value: Yes. $10 or less/month.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Paid plans from: $11–20/month: No. $10 or less/month

Paid plans from: $11–20/month

Typed value: No. $10 or less/month.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Paid plans from: $21–40/month: No. $10 or less/month

Paid plans from: $21–40/month

Typed value: No. $10 or less/month.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Paid plans from: $41–100/month: No. $10 or less/month

Paid plans from: $41–100/month

Typed value: No. $10 or less/month.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Paid plans from: Over $100/month: No. $10 or less/month

Paid plans from: Over $100/month

Typed value: No. $10 or less/month.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Paid plans from: Contact sales: No. $10 or less/month

Paid plans from: Contact sales

Typed value: No. $10 or less/month.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Keeps going with laptop closed: Yes cross-checked

Keeps going with laptop closed

Typed value: Yes.

The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket. Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

  • Local: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Byo remote: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Self hosted: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Managed cloud: Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.
  • Client disconnect: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Other device continuation: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Remote use

    Finding: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.

  2. Jcode: Cloud session CLI

    Finding: Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

Open-source license: Yes. MIT cross-checked

Open-source license

Typed value: Yes. MIT.

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Client license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Server license: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source visibility: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Source revision: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.
  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

Any desktop app: Yes

Any desktop app

Typed value: Yes.

Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

  • Desktop os: Jcode Desktop ships a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP.
  • Cli: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.
  • Task actions: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.
  • Notifications: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.
  • Cross device continuity: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.
  • The scoped first-party source pass does not establish browser, mobile_browser, editor_extensions. No hands-on scenario was run.
  1. Jcode: Install; First run

    Finding: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.

  2. Jcode: Download

    Finding: Jcode Desktop has a universal macOS DMG requiring macOS 13 or newer, Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP. Linux packages are not repository-signed and the Windows app is not code-signed. The page does not label the desktop app beta.

  3. Jcode: Mobile continuation

    Finding: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.

Paid plan up to $20/month: Yes. $10 or less/month

Paid plan up to $20/month

Typed value: Yes. $10 or less/month.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Paid plan up to $40/month: Yes. $10 or less/month

Paid plan up to $40/month

Typed value: Yes. $10 or less/month.

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • Currency: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Interval: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Included usage: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Credits: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Overages: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • Model cost: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.
  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

Any phone client: Yes

Any phone client

Typed value: Yes.

Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

  • Mobile apps: The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.
  • The scoped first-party source pass does not establish browser, mobile_browser, editor_extensions. No hands-on scenario was run.
  1. Jcode Mobile public beta

    Finding: Jcode Mobile is a native iPhone client with a public TestFlight join link at testflight.apple.com/join/ZHSYwcyf. It needs a Jcode account and supports agent messages and session continuation. The published client is iOS; no Android distribution is listed.

All public findings

Findings may summarize a source. They are not presented as verbatim statements.

jcode:ACC-01: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

jcode:ACC-01

Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients. Jcode Desktop has a universal macOS DMG (macOS 13+), Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP; Linux packages are not repository-signed and the Windows app is not code-signed. The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. The native iPhone client has a public TestFlight beta requiring a Jcode account. No Android release is listed.

  • The scoped first-party source pass does not establish browser, mobile_browser, editor_extensions. No hands-on scenario was run.
  1. Jcode: Install; First run

    Finding: Jcode provides a terminal UI and product CLI on macOS, Linux and Windows. jcode run is noninteractive, serve starts a persistent daemon and connect attaches clients.

  2. Jcode: Download

    Finding: Jcode Desktop has a universal macOS DMG requiring macOS 13 or newer, Linux x86_64 packages with ARM64 when available, and a portable Windows 10/11 ZIP. Linux packages are not repository-signed and the Windows app is not code-signed. The page does not label the desktop app beta.

  3. Jcode: Mobile continuation

    Finding: The /mobile command moves a session and its swarm to Jcode Cloud and requests a phone-app push; an existing cloud session only requests the notification. Phone operating-system availability is not specified here.

  4. Jcode Mobile public beta

    Finding: Jcode Mobile is a native iPhone client with a public TestFlight join link at testflight.apple.com/join/ZHSYwcyf. It needs a Jcode account and supports agent messages and session continuation. The published client is iOS; no Android distribution is listed.

jcode:ACC-02: Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

jcode:ACC-02

Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness. Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session. Jcode supplies its own agent loop. Its provider transports do not run the named third-party coding-agent harnesses.

  • The scoped first-party source pass does not establish session_integration, mixed_harness_operation. No hands-on scenario was run.
  1. Jcode: Providers and login; Any compatible endpoint

    Finding: Jcode is its own coding harness with Claude, OpenAI, Gemini, Copilot and Azure provider logins, local Ollama/LM Studio and named OpenAI-compatible endpoints. Model-provider access does not establish running Claude Code or Codex CLI as its harness.

  2. Jcode Antigravity support at v0.99.1

    Finding: Jcode v0.99.1 implements Antigravity as a Google Cloud Code model-provider transport using an HTTP client and model catalog. This does not establish a separate Antigravity coding-agent session.

  3. Jcode provider registry and harness boundary

    Finding: The inspected product runs the Jcode agent loop and tools. Provider adapters call model services rather than starting independent Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Grok, Aider or Antigravity harness sessions. Grok explicitly launches no grok subprocess; Cursor uses direct HTTP/2.

jcode:ACC-03: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts. cross-checked

jcode:ACC-03

Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Providers and login; Headless logins

    Finding: Jcode supports subscription OAuth and direct API providers, Claude subscription login and OpenAI/ChatGPT/Codex login, plus local model servers. /account switches provider accounts.

jcode:ACC-04: Install the binary, run jcode in the project folder and choose a provider login. Remote Unix hosts can run a persistent daemon reached through SSH socket forwarding. cross-checked

jcode:ACC-04

Install the binary, run jcode in the project folder and choose a provider login. Remote Unix hosts can run a persistent daemon reached through SSH socket forwarding.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: First run; Remote use

    Finding: Install the binary, run jcode in the project folder and choose a provider login. Remote Unix hosts can run a persistent daemon reached through SSH socket forwarding.

jcode:ACC-05: The TypeScript SDK launches a private Jcode process or attaches through api-bridge to a local or forwarded remote daemon, with session and streaming operations. cross-checked

jcode:ACC-05

The TypeScript SDK launches a private Jcode process or attaches through api-bridge to a local or forwarded remote daemon, with session and streaming operations.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: TypeScript SDK

    Finding: The TypeScript SDK launches a private Jcode process or attaches through api-bridge to a local or forwarded remote daemon, with session and streaming operations.

jcode:ACC-06: Jcode loads global and project MCP configuration and imports Claude Code/Codex MCP servers. Only stdio MCP servers are supported; HTTP/SSE entries are skipped. Markdown skills can load on relevance or explicit invocation. cross-checked

jcode:ACC-06

Jcode loads global and project MCP configuration and imports Claude Code/Codex MCP servers. Only stdio MCP servers are supported; HTTP/SSE entries are skipped. Markdown skills can load on relevance or explicit invocation.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MCP servers; Skills

    Finding: Jcode loads global and project MCP configuration and imports Claude Code/Codex MCP servers. Only stdio MCP servers are supported; HTTP/SSE entries are skipped. Markdown skills can load on relevance or explicit invocation.

jcode:PLAN-01: Users start an interactive project session or submit a noninteractive prompt through jcode run. External-tracker intake was not established. cross-checked

jcode:PLAN-01

Users start an interactive project session or submit a noninteractive prompt through jcode run. External-tracker intake was not established.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: First run

    Finding: Users start an interactive project session or submit a noninteractive prompt through jcode run. External-tracker intake was not established.

jcode:PLAN-02: Plans consist of phases, lanes and items with names, descriptions, lifecycle status, priority and confidence. Updates target names; generated internal IDs survive plan replacement when names stay the same. cross-checked

jcode:PLAN-02

Plans consist of phases, lanes and items with names, descriptions, lifecycle status, priority and confidence. Updates target names; generated internal IDs survive plan replacement when names stay the same.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Todo planning hierarchy

    Finding: Plans consist of phases, lanes and items with names, descriptions, lifecycle status, priority and confidence. Updates target names; generated internal IDs survive plan replacement when names stay the same.

jcode:PLAN-03: Phases are ordered, lanes can run in parallel and items run in lane order. A lane can name earlier prerequisite tasks; cancelled/deleted prerequisites do not satisfy it. Completely blocked is a condition with a reason, separate from lifecycle state. cross-checked

jcode:PLAN-03

Phases are ordered, lanes can run in parallel and items run in lane order. A lane can name earlier prerequisite tasks; cancelled/deleted prerequisites do not satisfy it. Completely blocked is a condition with a reason, separate from lifecycle state.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Todo planning hierarchy; Completely blocked

    Finding: Phases are ordered, lanes can run in parallel and items run in lane order. A lane can name earlier prerequisite tasks; cancelled/deleted prerequisites do not satisfy it. Completely blocked is a condition with a reason, separate from lifecycle state.

jcode:PLAN-04: Repository and global AGENTS.md load into the corresponding scope. Jcode also stores memory and skills, with explicit /memory and /skills controls. Memory correctness has not been tested. cross-checked

jcode:PLAN-04

Repository and global AGENTS.md load into the corresponding scope. Jcode also stores memory and skills, with explicit /memory and /skills controls. Memory correctness has not been tested.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: First run; Other files; Skills

    Finding: Repository and global AGENTS.md load into the corresponding scope. Jcode also stores memory and skills, with explicit /memory and /skills controls. Memory correctness has not been tested.

jcode:PLAN-05: When one agent edits a file another has read, the server notifies the reader, which can inspect the diff. This does not prove automatic conflict-free integration. cross-checked

jcode:PLAN-05

When one agent edits a file another has read, the server notifies the reader, which can inspect the diff. This does not prove automatic conflict-free integration.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Swarm

    Finding: When one agent edits a file another has read, the server notifies the reader, which can inspect the diff. This does not prove automatic conflict-free integration.

jcode:PLAN-06: Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog. cross-checked

jcode:PLAN-06

Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Todo planning hierarchy

    Finding: Native saved todo items have stable internal IDs, names, descriptions, priority, confidence, states and phase/lane membership. They are separate items inside a session plan, not a cross-project issue backlog.

jcode:PLAN-07: The coordinator owns the shared versioned plan and can propose, approve, assign and control tasks. Workers receive an assigned todo lane rendered before work starts. Other workers cannot freely mutate the shared plan. cross-checked

jcode:PLAN-07

The coordinator owns the shared versioned plan and can propose, approve, assign and control tasks. Workers receive an assigned todo lane rendered before work starts. Other workers cannot freely mutate the shared plan.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Coordinator; Agents

    Finding: The coordinator owns the shared versioned plan and can propose, approve, assign and control tasks. Workers receive an assigned todo lane rendered before work starts. Other workers cannot freely mutate the shared plan.

jcode:COORD-01: Multiple agents can work concurrently in the same repository; the server manages messaging, completion status and file-change notifications. Actual concurrency and performance benchmarks were not rerun. cross-checked

jcode:COORD-01

Multiple agents can work concurrently in the same repository; the server manages messaging, completion status and file-change notifications. Actual concurrency and performance benchmarks were not rerun.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Swarm

    Finding: Multiple agents can work concurrently in the same repository; the server manages messaging, completion status and file-change notifications. Actual concurrency and performance benchmarks were not rerun.

jcode:COORD-02: Only root sessions spawn swarm workers. The root coordinator assigns shared-plan tasks and controls that plan through a single coordinator slot. cross-checked

jcode:COORD-02

Only root sessions spawn swarm workers. The root coordinator assigns shared-plan tasks and controls that plan through a single coordinator slot.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Root-only spawning; Coordinator

    Finding: Only root sessions spawn swarm workers. The root coordinator assigns shared-plan tasks and controls that plan through a single coordinator slot.

jcode:COORD-03: Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status. cross-checked

jcode:COORD-03

Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Swarm

    Finding: Jcode agents can autonomously spawn a swarm, making the original agent coordinator. Server-managed messages support direct, repository-wide and server-wide communication and completion status.

jcode:COORD-04: Ambient mode is implemented but disabled by default. It runs one proactive background agent, self-schedules wakeups and prioritizes interactive sessions; later design ideas in the document are not all shipped. cross-checked

jcode:COORD-04

Ambient mode is implemented but disabled by default. It runs one proactive background agent, self-schedules wakeups and prioritizes interactive sessions; later design ideas in the document are not all shipped.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Status; Key design decisions

    Finding: Ambient mode is implemented but disabled by default. It runs one proactive background agent, self-schedules wakeups and prioritizes interactive sessions; later design ideas in the document are not all shipped.

jcode:COORD-05: Enter interleaves a message with the working agent and Shift+Enter queues it. Commands can resume, fork, compact or rewind sessions. cross-checked

jcode:COORD-05

Enter interleaves a message with the working agent and Shift+Enter queues it. Commands can resume, fork, compact or rewind sessions.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Keybindings; Slash commands

    Finding: Enter interleaves a message with the working agent and Shift+Enter queues it. Commands can resume, fork, compact or rewind sessions.

jcode:COORD-06: Desktop offers a spatial session canvas and zoomed-out overview with task and orchestration views. No six-task navigation fixture or measured effort was run. cross-checked

jcode:COORD-06

Desktop offers a spatial session canvas and zoomed-out overview with task and orchestration views. No six-task navigation fixture or measured effort was run.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Every session on one spatial canvas

    Finding: Desktop offers a spatial session canvas and zoomed-out overview with task and orchestration views. No six-task navigation fixture or measured effort was run.

jcode:COORD-07: Users start quick prompts, headless requests or swarm sessions, with provider/model/effort and feature configuration. cross-checked

jcode:COORD-07

Users start quick prompts, headless requests or swarm sessions, with provider/model/effort and feature configuration.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: First run; Configure

    Finding: Users start quick prompts, headless requests or swarm sessions, with provider/model/effort and feature configuration.

jcode:RUN-01: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket. Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host. cross-checked

jcode:RUN-01

The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket. Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Remote use

    Finding: The daemon owns sessions, tools and provider calls. It can run locally or on a user SSH server, where it continues after disconnect; a local client can forward the remote Unix socket.

  2. Jcode: Cloud session CLI

    Finding: Detached cloud turns run on the session recorded cloud host and reject a second active owner. /mobile migrates session and swarm to the managed Jcode Cloud host.

jcode:RUN-02: Swarm coordination supports optional Git worktrees and worktree manager roles for separate code work and later integration. These are checkout boundaries, not hostile-code sandboxes. The optional Jcode Cloud service offers cloud-agent virtual machines.

jcode:RUN-02

Swarm coordination supports optional Git worktrees and worktree manager roles for separate code work and later integration. These are checkout boundaries, not hostile-code sandboxes. The optional Jcode Cloud service offers cloud-agent virtual machines.

  • The scoped first-party source pass does not establish checkout, branch, container, os_sandbox, filesystem, process, network, secrets, security_boundary. No hands-on scenario was run.
  1. Jcode: Swarm Architecture; Worktree Manager

    Finding: Swarm coordination supports optional Git worktrees and worktree manager roles for separate code work and later integration. These are checkout boundaries, not hostile-code sandboxes.

  2. Jcode hosted pricing and VM execution

    Finding: The pricing page explicitly offers cloud agent VMs, with 50 Jcode Cloud machine hours per $10 monthly plan. Paid model overage uses provider API prices; local MIT software and user-supplied subscriptions remain separate.

jcode:RUN-03: Normal uninstall retains config, authentication, memory and sessions unless purge is requested. A remote daemon keeps working after disconnection and --resume reopens its saved session. cross-checked

jcode:RUN-03

Normal uninstall retains config, authentication, memory and sessions unless purge is requested. A remote daemon keeps working after disconnection and --resume reopens its saved session.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Uninstall; Remote use

    Finding: Normal uninstall retains config, authentication, memory and sessions unless purge is requested. A remote daemon keeps working after disconnection and --resume reopens its saved session.

jcode:RUN-04: Cloud handoff does not make machines identical. Metadata-only environment requests transfer scoped project files or allowlisted credentials; local callbacks have a limited lifetime and disconnect revokes future access. Copied resources remain until removed or rotated. cross-checked

jcode:RUN-04

Cloud handoff does not make machines identical. Metadata-only environment requests transfer scoped project files or allowlisted credentials; local callbacks have a limited lifetime and disconnect revokes future access. Copied resources remain until removed or rotated.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Cloud environment requirements

    Finding: Cloud handoff does not make machines identical. Metadata-only environment requests transfer scoped project files or allowlisted credentials; local callbacks have a limited lifetime and disconnect revokes future access. Copied resources remain until removed or rotated.

jcode:RUN-05: cloud wait exits unsuccessfully on timeout without cancelling the remote turn. Failed inspection and remote-turn failure remain errors; an active owner blocks a detached turn. cross-checked

jcode:RUN-05

cloud wait exits unsuccessfully on timeout without cancelling the remote turn. Failed inspection and remote-turn failure remain errors; an active owner blocks a detached turn.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Cloud session CLI

    Finding: cloud wait exits unsuccessfully on timeout without cancelling the remote turn. Failed inspection and remote-turn failure remain errors; an active owner blocks a detached turn.

jcode:RUN-06: Todo lanes show worker activity, observed tokens, throughput, connection, elapsed time and tool intent. Missing telemetry is not inferred from context size. Waiting/stopped workers show available reasons. cross-checked

jcode:RUN-06

Todo lanes show worker activity, observed tokens, throughput, connection, elapsed time and tool intent. Missing telemetry is not inferred from context size. Waiting/stopped workers show available reasons.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Live worker status in todo lanes

    Finding: Todo lanes show worker activity, observed tokens, throughput, connection, elapsed time and tool intent. Missing telemetry is not inferred from context size. Waiting/stopped workers show available reasons.

jcode:RUN-07: The /usage and /info commands show provider limits, session information and tokens. Token and quota visibility is not proof of per-task invoiced spend. cross-checked

jcode:RUN-07

The /usage and /info commands show provider limits, session information and tokens. Token and quota visibility is not proof of per-task invoiced spend.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Slash commands; Provider usage

    Finding: The /usage and /info commands show provider limits, session information and tokens. Token and quota visibility is not proof of per-task invoiced spend.

jcode:RUN-08: Ambient mode admits only one ambient instance and gives interactive sessions priority. Its later design/resource-policy examples are not all implemented; no safe load test was performed. cross-checked

jcode:RUN-08

Ambient mode admits only one ambient instance and gives interactive sessions priority. Its later design/resource-policy examples are not all implemented; no safe load test was performed.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Key design decisions

    Finding: Ambient mode admits only one ambient instance and gives interactive sessions priority. Its later design/resource-policy examples are not all implemented; no safe load test was performed.

jcode:TEAM-02: The local daemon pairs devices without human organization roles. The enterprise contact page does not establish roles or SSO for the separate closed hosted service.

jcode:TEAM-02

The local daemon pairs devices without human organization roles. The enterprise contact page does not establish roles or SSO for the separate closed hosted service.

  • The scoped first-party source pass does not establish project_roles, task_roles, membership, sso, provisioning, unauthorized_access, revocation, plan_scope. No hands-on scenario was run.
  1. Jcode local paired-client access

    Finding: The local daemon pairs devices to one host session account, with device-token revocation and no human membership, organization-role or enterprise SSO model. This inspection does not establish the access features of the separately hosted Jcode Cloud service.

jcode:TEAM-03: Temporary local environment access is scoped to the handoff lease, defaults to twenty-four hours and ends on disconnect/session switch. The credential allowlist excludes arbitrary home files and SSH private keys. This is not a verified general command-approval system. cross-checked

jcode:TEAM-03

Temporary local environment access is scoped to the handoff lease, defaults to twenty-four hours and ends on disconnect/session switch. The credential allowlist excludes arbitrary home files and SSH private keys. This is not a verified general command-approval system.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Temporary callback; Credential allowlist

    Finding: Temporary local environment access is scoped to the handoff lease, defaults to twenty-four hours and ends on disconnect/session switch. The credential allowlist excludes arbitrary home files and SSH private keys. This is not a verified general command-approval system.

jcode:TEAM-04: Plan item identity is preserved through matching-name replacement and explicit rename. Transcript/log integrity and multi-user attribution were not tested. cross-checked

jcode:TEAM-04

Plan item identity is preserved through matching-name replacement and explicit rename. Transcript/log integrity and multi-user attribution were not tested.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Todo planning hierarchy

    Finding: Plan item identity is preserved through matching-name replacement and explicit rename. Transcript/log integrity and multi-user attribution were not tested.

jcode:TEAM-05: Jcode Desktop renders file diffs beside live sessions, and the TUI /diff command cycles the diff display mode. No guided human review measurement was run. cross-checked

jcode:TEAM-05

Jcode Desktop renders file diffs beside live sessions, and the TUI /diff command cycles the diff display mode. No guided human review measurement was run.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Diffs, rendered

    Finding: Jcode Desktop renders file diffs, Mermaid diagrams, inline images and compact tool calls beside live agent sessions. No guided human review measurement was run.

  2. Jcode: Slash commands

    Finding: /commit makes logical commits, /commit-push can push them and /diff changes diff rendering. No product-owned PR creation flow was established.

jcode:SHIP-01: The desktop client renders diffs, Mermaid diagrams, inline images and tool cards beside agent conversations. Persistent revision-bound cross-task artifact retrieval remains unverified. cross-checked

jcode:SHIP-01

The desktop client renders diffs, Mermaid diagrams, inline images and tool cards beside agent conversations. Persistent revision-bound cross-task artifact retrieval remains unverified.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Side by side, all live

    Finding: The desktop client renders diffs, Mermaid diagrams, inline images and tool cards beside agent conversations. Persistent revision-bound cross-task artifact retrieval remains unverified.

jcode:SHIP-03: The inspected public Jcode CLI/desktop implementation has no dedicated native PR creation or management operation; agents can use generic shell/MCP tools. The optional closed Jcode Cloud service does not have enough public workflow detail to establish a product-wide PR value.

jcode:SHIP-03

The inspected public Jcode CLI/desktop implementation has no dedicated native PR creation or management operation; agents can use generic shell/MCP tools. The optional closed Jcode Cloud service does not have enough public workflow detail to establish a product-wide PR value.

  • The scoped first-party source pass does not establish branches, worktrees, comments, ci_response, rebase, conflicts, product_state. No hands-on scenario was run.
  • Optional Jcode Cloud is closed; absence from the inspected local client does not establish a global restriction.
  1. Jcode: Slash commands

    Finding: /commit makes logical commits, /commit-push can push them and /diff changes diff rendering. No product-owned PR creation flow was established.

  2. Jcode PR workflow inspection

    Finding: The scoped command/tool surfaces implement commit and push, but no dedicated PR creation or management operation. Ambient permission requests can name create_pull_request without implementing that action. External shell or MCP tools can still operate a forge.

jcode:OWN-01: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope. cross-checked

jcode:OWN-01

Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: Jcode source is MIT licensed at the pinned revision, including a free-of-charge permission grant. Optional hosted inference/cloud services have separate commercial scope.

jcode:OWN-02: The Jcode daemon, TUI and tools can run on a user-controlled machine or SSH host, with direct model credentials or local servers. Optional Jcode Cloud is not required for local use. cross-checked

jcode:OWN-02

The Jcode daemon, TUI and tools can run on a user-controlled machine or SSH host, with direct model credentials or local servers. Optional Jcode Cloud is not required for local use.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: From source; Remote use

    Finding: The Jcode daemon, TUI and tools can run on a user-controlled machine or SSH host, with direct model credentials or local servers. Optional Jcode Cloud is not required for local use.

jcode:OWN-03: Default usage telemetry may include provider OAuth email, installation ID and numeric/categorical usage. Full transcript sharing is separately opt-in. jcode telemetry disable, JCODE_NO_TELEMETRY=1, DO_NOT_TRACK=1 or a no_telemetry file disables telemetry. cross-checked

jcode:OWN-03

Default usage telemetry may include provider OAuth email, installation ID and numeric/categorical usage. Full transcript sharing is separately opt-in. jcode telemetry disable, JCODE_NO_TELEMETRY=1, DO_NOT_TRACK=1 or a no_telemetry file disables telemetry.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Ordinary telemetry; How to Opt Out

    Finding: Default usage telemetry may include provider OAuth email, installation ID and numeric/categorical usage. Full transcript sharing is separately opt-in. jcode telemetry disable, JCODE_NO_TELEMETRY=1, DO_NOT_TRACK=1 or a no_telemetry file disables telemetry.

jcode:OWN-04: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

jcode:OWN-04

Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software. Paid plans allocate Jcode Cloud VM machine hours in proportion to their monthly price.

  • The scoped first-party source pass does not establish seats, seat_minimum, workspace_fees, trial, taxes. No hands-on scenario was run.
  1. Jcode: Token plans; Billing details

    Finding: Optional hosted plans start at USD 10 monthly with USD 20 inference credit and fifty Jcode Cloud machine hours. Extra inference defaults to a zero-dollar cap; paid overage uses provider API prices after raising the cap. Remote Rust builds start at the USD 20 plan. This is separate from free MIT local software.

  2. Jcode hosted pricing and VM execution

    Finding: The pricing page explicitly offers cloud agent VMs, with 50 Jcode Cloud machine hours per $10 monthly plan. Paid model overage uses provider API prices; local MIT software and user-supplied subscriptions remain separate.

jcode:OWN-06: v1.0.0-preview.199, published November 6, is an opt-in v1 pre-release of experimental binaries, with production use directed to the stable channel. Open issue topics include syntax highlighting, ACP cancellation and compaction refusals, without reproduced universal findings.

jcode:OWN-06

v1.0.0-preview.199, published November 6, is an opt-in v1 pre-release of experimental binaries, with production use directed to the stable channel. Open issue topics include syntax highlighting, ACP cancellation and compaction refusals, without reproduced universal findings.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Preview release

    Finding: v1.0.0-preview.199, published November 6, is an opt-in v1 pre-release of experimental binaries; the release notes direct production use to the stable channel. Open issue topics include syntax highlighting, ACP cancellation and compaction refusals, without reproduced universal findings.

jcode:OWN-08: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions. cross-checked

jcode:OWN-08

The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: MIT License

    Finding: The application can be downloaded, used and self-hosted as free MIT software. Optional token/cloud plans and Rust-build trials have separate prices and trial conditions.

jcode:OWN-09: The hosted plans disclose recurring USD charges, inference credit, cloud hours, API-price overage and separate build-overage limits. Local application use and model subscriptions remain separate cost routes. cross-checked

jcode:OWN-09

The hosted plans disclose recurring USD charges, inference credit, cloud hours, API-price overage and separate build-overage limits. Local application use and model subscriptions remain separate cost routes.

  • Documentation evidence only. Remaining atomic questions and enforcement under failure have not been established by a bounded workflow test.
  1. Jcode: Billing details

    Finding: The hosted plans disclose recurring USD charges, inference credit, cloud hours, API-price overage and separate build-overage limits. Local application use and model subscriptions remain separate cost routes.