JMP — Joint Model Participation

Models participate. Real tools execute.

Features · Quick start · Research · Architecture · Security

What is JMP?

Joint Model Participation means giving each model a specific job—not asking one model to do everything. JMP is a local desktop coding agent: one model chooses the next action, a selected generator supplies its arguments, and real tools execute the validated call.

When the selected tool's schema fixes every argument, code supplies them directly—no generation call. The next decision uses what actually happened, rather than a speculative plan. This is a single controlled agent loop, not a swarm of autonomous agents.

You get a React desktop workspace for conversations, live tool activity, saved sessions and inspectable artifacts—with a CLI using the same backend.

Local tools, optional local generation. Windows desktop Settings can download and run either Bonsai 2 27B model with one click, replacing DeepSeek. Jev still receives routing context and needs its API key; this is not fully offline. Local model setup, requirements and privacy →

What it does

The Files screen shows saved session artifacts; it is not a general filesystem explorer. There are no subagents, synthetic-thinking gates or dedicated planning tools in the runtime.

How it works

flowchart LR
    U[User request + actual history] --> J{Jev selects}
    J -->|Tool| P{Schema fixes all arguments?}
    P -->|Yes| B[Code supplies fixed arguments]
    P -->|No| D[Selected generator: DeepSeek / OpenAI / Bonsai]
    B --> V[Validate one native call]
    D --> V
    V --> T[OpenHands / MCP tool]
    T --> O[Persist actual result]
    O --> U
    J -->|Done proposed| C{Jev completion review}
    C -->|Complete| S[Factual final summary]
    C -->|Work remains| J
    J -->|Ask| A[Pause for clarification]

The boundary is deliberate: Jev chooses the action; the generation model cannot silently switch to another tool. Arguments are validated before effects. Incomplete calls do not execute. Interrupted effects require review rather than automatic replay.

v0.2.3 cost improvement: schema-determined arguments now bypass generation. Optional/free/unsupported fields still use the original model path; routing and execution safeguards are unchanged. The unvalidated neural argument adapter is research-only. No whole-agent saving percentage is claimed. The Windows release now packages this previously validated source improvement. Exact scope and tests →

v0.2.2 context fix: corrects the repeatable context-accounting overflow and adds intent-relevant archival search with a Jev-selectable recall tool. Research, results and honest limits → This is a bounded working window over saved history—not literal infinite context.

v0.2.1 hotfix: follow-ups retain the previous assistant response as conversation, not execution evidence. A separate Jev completion review catches premature done decisions and sends unfinished work back to tool selection. Pure conversation does not require a tool call. See completion policy and limits.

Context compaction is deterministic—not another model's generated summary. Earlier requests remain pinned except for credential redaction; oversized pinned context pauses visibly instead of silently dropping requirements.

Backend contract → · Desktop architecture →

Quick start

Desktop from source

Use Python 3.12, Node 24 (tested), and Windows with WebView2 installed. The standalone Windows build bundles Python, dependencies and WebView2 instead. Native macOS/Linux packaging has not been validated.

git clone https://github.com/morcoan/JMP.git
cd JMP
python -m venv .venv
.venv\Scripts\Activate.ps1
python -m pip install -r requirements.txt -c requirements.lock
python -m pip install -r requirements-desktop.txt -c requirements-desktop.lock
python scripts/prepare_codex.py
cd frontend
npm ci
npm run build
cd ..
python desktop.py

Add your TypeSafe/Jev key and configure a generation provider in Settings, choose a workspace and send a task. DeepSeek requires its own API key; local Bonsai and OpenAI subscription mode do not. Saving settings does not call a model.

Use your ChatGPT subscription (desktop)

1. In Settings → Generation provider, choose OpenAI · ChatGPT subscription.
2. Click Sign in with ChatGPT and complete sign-in in your browser. JMP detects completion automatically. Your plan must include Codex access.
3. Choose a model from the runtime’s advertised account catalog, select one of its supported reasoning levels, and click Save generation settings. The status bar shows the saved model and effort.

No separate Codex, Node, npm, or terminal setup is needed by Windows app users. The official native Codex runtime (pinned to 0.155.1) is bundled with JMP. Source developers prepare that same verified runtime once with python scripts/prepare_codex.py; the Windows release builder does this automatically. Settings also provides Cancel sign-in, Sign out, and connection status.

The Jev routing key is still required. OpenAI mode overrides local Bonsai and never falls back to DeepSeek or OpenAI API-key billing. Model availability and reasoning levels depend on your account; subscription usage limits apply. The picker no longer accepts arbitrary model IDs or incompatible effort levels. Catalog entries are rechecked before each run; a removed model, unknown context profile, changed reasoning support, or server model reroute blocks the request rather than silently substituting a different model. Catalog visibility is not proof of current quota/entitlement: the service can still reject a request. Generation changes are blocked during a run and apply to the next run. Damaged saved preferences block generation until repaired in Settings rather than silently selecting a fallback provider.

Codex owns sign-in/refresh in a dedicated codex folder under JMP's state directory, not your usual Codex profile or the Windows API-key vault. Treat that folder as sensitive. No tokens or OAuth URLs are copied into session logs or the frontend. The app owns this profile's runtime configuration; do not put personal Codex customizations there.

One background app-server process is shared across requests and closed with the app. Each generation uses a fresh ephemeral thread in an isolated temporary folder, with shell/browser/agent tools disabled and read-only sandboxing. Runtime tool/approval requests are rejected; JMP executes the validated selected tool itself. Context goes to both Jev and OpenAI. Private reasoning/raw runtime events are not forwarded to the UI or session logs. Interrupted/crashed generations are never automatically replayed. Subscription generation is a desktop setting, not a CLI .env option.

Context and failure safeguards

OpenAI context budgets use reviewed default windows from the pinned runtime’s upstream model metadata (jmp/codex_limits.py). The public catalog protocol omits window sizes, so unreviewed models are disabled instead of assigning a guessed window. Input is conservatively bounded in UTF-8 serialized request bytes, including JSON escaping, instructions and tool/output schemas. At least half the reviewed window is reserved for runtime overhead, reasoning and output; the default input cap is 96,000 bytes, not a claim to expose the full model window. JEV_CODEX_CONTEXT_BYTES can lower/change this cap within the selected model’s safe bound. OpenAI ignores DS_CONTEXT_BYTES and LLM_MODEL; Jev routing still uses its own smaller budget.

Compaction preserves user constraints and archives old observations with explicit omission markers. If mandatory context no longer fits, the run pauses with saved history intact; this is not unlimited conversation memory. Switching models rebuilds context from the same saved session. Each generated request receives a final size check before a native turn starts.

Expired sign-in, quota/rate limits, connection failures and context overflow use allowlisted actionable errors, without forwarding raw provider diagnostics. Tests cover these failures with an isolated protocol fixture; live refresh, quota and long-session behavior still needs a signed-in account to verify.

python main.py --workspace /path/to/project "Fix the failing tests"
python main.py --list
python main.py --session SESSION_ID "Add an edge-case test"
python main.py --session SESSION_ID --compact

Standalone Windows EXE

Download the unsigned Windows x64 EXE from the latest release. Existing release assets may still use the previous app name; this source rename does not rebuild published binaries. A single-file Windows x64 build is also supported: release/JMP.exe after building. It includes Python, the frontend/fonts and Fixed Version WebView2. Project-specific tools such as Git, Node, Python interpreters for your projects, or MCP servers are not bundled. Build outputs are not committed to this repository.

The tested build is unsigned. First launch asks you to review Microsoft's runtime terms, then configure your keys. Personal state lives under %LOCALAPPDATA%\JMP; the EXE does not load a neighboring .env or mcp.json.

Build the EXE → · Desktop controls →

Upgrading from the previous name

JMP was previously named JevSeek. Existing profiles and saved keys remain supported; the rename does not automatically merge or delete personal data. See rename and existing-profile compatibility.

Research that shaped the design

JMP grew out of local experiments, including configurations that did not work. The implementation follows the evidence observed—not a claim of universal agent superiority.

The complete research archive also publishes the later intelligence, grounding, efficiency and cost studies—including every negative or incomplete avenue. The clearest new win is a bounded decision endpoint with 0.225 s median latency and estimated 34% lower off-peak API cost than nonthinking Flash at equal observed accuracy. It is not an automatic whole-agent speedup. Measured efficiency · Cost accounting

Important limits: these are small local studies, not a broad benchmark suite. All main arms in the ORIGINAL build-engine comparisons used Jev; there is no whole-agent Jev-vs-DeepSeek-router ablation in those studies. Provider load, cache behavior and model aliases can change. Test success is not a security guarantee, and an unfinished run is not a performance win.

Read the research breakdown →

Methods, numbers, failures, limitations and reproduction commands are documented there. Benchmark source and evaluator fixtures are public; raw personal sessions, traces and generated workspaces are deliberately excluded.

Verification

Latest local source validation for the JMP rebrand:

• 174 Python tests + 10 subtests, including branding and existing-profile compatibility.
• 8 frontend state tests, TypeScript checks and a production Vite build.
• Built-UI checks for the JMP title, expanded name, settings and sign-in flow: zero reported axe violations or console errors.
• A real bundled-runtime smoke check: catalog, model/effort selection, process reuse, ephemeral threads, OAuth cancellation and shutdown—no model calls.

Earlier recorded validation also includes:

• 10 research regression tests.
• 19 core UI screens + 5 key/terms screens with zero reported axe A/AA violations and console errors in their recorded audits—not a human screen-reader certification.
• An isolated EXE check with Python/Node removed from PATH: real vault save/remove, file read/write/edit, PowerShell, bundled WebView2 and MCP-helper execution.
• A source-desktop, real-provider read-only integration check. This is separate from the offline EXE check and is not a model-quality benchmark.

These are historical recorded checks, not a claim that hosted CI is running. The v0.2.3 argument bypass adds 28 offline tests; the archived neural argument prototype retains 39 offline tests but has no completed live quality/cost trial.

python -m unittest -v test_argument_offload test_backend test_bonsai test_branding test_codex test_credentials test_desktop test_mcp_setup test_public_audit
python -m unittest discover -s benchmarks -p test_deliberation.py -v
cd frontend
npm test
npm run build

Security & limits

• Not a sandbox. Tools have your account's privileges. Use trusted projects and MCP servers, or an isolated OS account/VM. Do not run as administrator.
• Protect your history. Sessions may contain private code/output despite best-effort redaction. Do not upload them in bug reports.
• Stop is cooperative. Native calls can take time to return; a stopped process does not prove a tool had no effects.
• API-backed inference. Provider billing/privacy terms apply. Microsoft WebView2 and SmartScreen also have disclosed network/privacy behavior.
• Keep the runtime current. Bundled Fixed WebView2 does not auto-update; maintainers must ship updates. Windows 11 is verified; fresh-VM certification and independent security review have not been performed.

Security policy → · Third-party notices →

Explore the repository

jmp/           Agent loop, context, sessions, native tools and desktop bridge
frontend/      React + TypeScript + CSS desktop interface
benchmarks/    Experimental runners and the independent build-engine evaluator
research/      Full study archive: wins, failures, limits, prototypes and summaries
docs/          Architecture, usage, desktop and release documentation
scripts/       Build, validation and privacy-safe export helpers
packaging/     Windows executable spec, icon and runtime version pin

Before contributing, run the relevant tests and python scripts/public_audit.py --history. Never commit .env, machine MCP configuration, agent memory, sessions or build outputs. Keep runtime changes separate from research experiments and label billable tests explicitly.

License: JMP's own source is licensed under the MIT License. Dependencies retain their respective licenses. JMP is an independent project, not an official DeepSeek, TypeSafe or OpenHands product.