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?
- 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
- Data
- /products/jcode.json · .md
- 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 itAgents 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 runsAccounts 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 subscriptionsWhere 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 runHow 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 apartParallel 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 workScheduled 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 runsGit 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 requestsLicence 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 sourcePrice
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 PriceTyped filters
Every value links to its receipt below. Read plan and surface restrictions before using a filter to decide.
| Filter | Value |
|---|---|
| Desktop OS: macOS | Yes |
| Desktop OS: Windows | Yes |
| Desktop OS: Linux | Yes |
| Web client | Unknown |
| Phone access: Native iOS | Yes |
| Phone access: Native Android | No |
| Phone access: Phone browser | Unknown |
| CLI | Yes cross-checked |
| Coding agents: Claude Code | No |
| Coding agents: Codex | No |
| Coding agents: Cursor Agent | No |
| Coding agents: Gemini CLI | No |
| Coding agents: OpenCode | No |
| Coding agents: Pi | No |
| Coding agents: Grok | No |
| Coding agents: Aider | No |
| Coding agents: Antigravity | No |
| Use my subscription | Yes cross-checked |
| Where agents run: On your computer | Yes cross-checked |
| Where agents run: On your own server | Yes cross-checked |
| Where agents run: In the vendor's cloud | Yes cross-checked |
| Workspace isolation: Git worktree | Yes |
| Workspace isolation: Container | Unknown |
| Workspace isolation: VM or microVM | Yes |
| Parallel runs | Yes cross-checked |
| Coordinator | Yes cross-checked |
| Native issue tracking | Yes cross-checked |
| Unattended triggers | Yes cross-checked |
| Shared prompting | Unknown |
| Team roles | Unknown |
| SSO | Unknown |
| Pull request workflow | Unknown |
| Review interface | Yes cross-checked |
| Product license: Apache-2.0 | No. MIT cross-checked |
| Product license: MIT | Yes. MIT cross-checked |
| Product license: GPL-3.0 | No. MIT cross-checked |
| Product license: GPL-3.0-or-later | No. MIT cross-checked |
| Product license: AGPL-3.0 | No. MIT cross-checked |
| Product license: AGPL-3.0-or-later | No. MIT cross-checked |
| Product license: Elastic License 2.0 | No. MIT cross-checked |
| Product license: Custom terms | No. MIT cross-checked |
| Product license: Proprietary | No. MIT cross-checked |
| Self-hosting | Yes cross-checked |
| Telemetry opt-out | Yes cross-checked |
| Free access | Yes cross-checked |
| Starting price: Free | Yes. Free cross-checked |
| Starting price: Up to $20/month | No. Free cross-checked |
| Starting price: $21–40/month | No. Free cross-checked |
| Starting price: $41–100/month | No. Free cross-checked |
| Starting price: Over $100/month | No. Free cross-checked |
| Starting price: Contact for pricing | No. Free cross-checked |
| Pricing model: Free, no paid plan | No |
| Pricing model: Free plan | Yes cross-checked |
| Pricing model: Subscription | Yes |
| Pricing model: Per seat | No |
| Pricing model: Usage-based | Yes |
| Pricing model: Per machine or compute | Yes |
| Pricing model: Bring your own key | Yes cross-checked |
| Pricing model: One-time purchase | No |
| Paid plans from: No paid plan | No. $10 or less/month |
| Paid plans from: $10 or less/month | Yes. $10 or less/month |
| Paid plans from: $11–20/month | No. $10 or less/month |
| Paid plans from: $21–40/month | No. $10 or less/month |
| Paid plans from: $41–100/month | No. $10 or less/month |
| Paid plans from: Over $100/month | No. $10 or less/month |
| Paid plans from: Contact sales | No. $10 or less/month |
| Lifecycle status: Active | Unknown |
| Lifecycle status: Sunsetting | Unknown |
| Keeps going with laptop closed | Yes cross-checked |
| Open-source license | Yes. MIT cross-checked |
| Any desktop app | Yes |
| Paid plan up to $20/month | Yes. $10 or less/month |
| Paid plan up to $40/month | Yes. $10 or less/month |
| Any phone client | Yes |
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
Finding: /commit makes logical commits, /commit-push can push them and /diff changes diff rendering. No product-owned PR creation flow was established.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.