AutoJev documentation

AutoJev is a free, open-source desktop app (Tauri 2, React 19, Rust) that runs one local gateway at http://127.0.0.1:9527/v1 for AI coding agents. You manage providers, models and routing rules in one place, connect agents with one click, and every request is routed to a model you choose: a fixed model, a load-balanced group, or an intelligent selection. AutoJev converts between OpenAI Responses, Chat Completions and Anthropic Messages, and records usage and estimated cost locally.

AutoJev is in early development. This guide describes version 0.1.6. Behaviour may change between releases; the GitHub repository is the source of truth.

Looking for the hosted Jev decision API (REST, MCP and Skills)? It now lives in the Jev API integration guide.

Install

Download the installer for your system from the download page or from GitHub Releases.

AutoJev is free. There is no paid plan and no AutoJev account. You bring your own provider keys, and requests go directly from your machine to those providers.

First run

1. Open AutoJev. The local gateway starts on 127.0.0.1:9527 (development builds use 9526).
2. Add at least one provider under Providers and one model under Models.
3. Optionally create a route under Routes.
4. Connect an agent under Agents, or copy connection parameters into any other client.
5. Send a test request from Debug, then check Logs to see which provider and model handled it.

Settings let you choose the language (English, 简体中文 or follow the system), the theme (light, dark or system, with four accent colours), and other preferences. Open settings with ⌘ , on macOS or Ctrl , on Windows and Linux.

Add a provider

A provider is an upstream API endpoint plus a key. AutoJev ships with presets:

Any OpenAI-compatible or Anthropic-compatible endpoint works through the compatible presets, for example Kimi (Moonshot), GLM (Zhipu), Qwen (DashScope), SiliconFlow, vLLM or LM Studio.

• Import: AutoJev can import existing providers from CC Switch (~/.cc-switch/cc-switch.db) and Termany (~/.termany/termany.db). Imports are de-duplicated by endpoint.
• Test: each provider has a connection test. A reply that contains only reasoning still counts as a pass.
• Enable or disable: disabled providers keep their configuration but are not used for routing.

See provider management and the provider pages for OpenAI, DeepSeek, OpenRouter, Ollama, OpenAI-compatible and Anthropic-compatible endpoints.

Models and speed tests

Each model belongs to a provider and has:

• API type — the protocol the upstream speaks: chat_completions, responses or messages. It must match the provider. Do not change it to Responses just because you plan to connect Codex; AutoJev converts on the way in.
• Model ID — the upstream model name, for example deepseek-chat.
• Prices — input, output and cache prices per 1M tokens, used for estimated cost and cost routing.
• Tier, tools, vision, reasoning flags and context window — metadata used by routing. They are configured estimates; they do not reject requests on their own, and the upstream decides what it supports.

A single model is exposed to agents as <provider-id>/<model-id>.

Speed tests

Speed tests measure first-content latency and output tokens per second. Each test sends three sequential streaming requests per model with a short fixed prompt (output capped at 128 tokens, 20-second timeout). Tests use real provider quota.

• Scheduled tests are on by default and run every 30 minutes; the interval is adjustable from 5 to 120 minutes in Settings → General. They keep running while the app sits in the tray.
• Up to 30 samples are kept per model. Real streaming requests also update the measurements.
• If no model is selected, a test run covers all enabled models.

Read more in model speed tests.

Routes

A route is a named group of candidate models with a strategy. Routes are exposed to agents as autojev/<route-id>, for example autojev/fast, autojev/quality or autojev/cheap.

Strategies

Model scope per route is either all enabled models or a selected list, each with its own priority and weight.

Decision preferences (intelligent selection)

Options:

• Prefer local models — favour Ollama models when they qualify (hidden for the speed preference, where measurements decide).
• Cost baseline — a reference model used to estimate savings in usage statistics.

The Jev decision model

Balanced and quality routes call a decision model. The default is OpenRouter Jev (https://openrouter.ai/api/alpha/decisions, model ~typesafe/jev-latest) with your own OpenRouter key. Configure it in Settings → Gateway & routing → Decision model, click Test Jev, then save.

• Only routing metadata (derived task features and candidate model metadata) is sent to Jev — not conversation content.
• If Jev answers with confidence below 0.5, an unknown candidate, an error, or does not respond within 8 seconds, AutoJev falls back to weighted load balancing and records the reason in the request log.
• A route with a single candidate never calls Jev.

Read more in smart routing.

Session affinity

Requests in the same session keep their selected model while it stays eligible, so an agent does not switch models mid-conversation. New sessions use the current ranking.

Connect agents

Open Agents. AutoJev detects installed agents and shows each configuration path and connection status. Select one or more models or routes per agent and click Connect. Detection alone never changes files.

How connecting works:

• Backup on connect. AutoJev backs up the original file before the first change.
• Restore on disconnect. Disconnecting restores the original configuration while keeping later edits you made that do not conflict with AutoJev's fields. If a file was absent before, restoring removes it.
• Batch update. Change the selection for several connected agents at once.
• Model picker. Where the client supports it, AutoJev writes all selected models and routes into the agent's model list (for example Codex's model catalog or Claude Code's modelPicker).
• Restart a running agent if it caches its configuration in memory.

Custom agents

Add any executable with launch arguments, an optional configuration path and an optional icon. AutoJev recognizes configuration templates for Kilo, OpenCode, OpenClaw, Hermes, Grok and Kimi. Custom agents use the first selected model or route as their default. A command test runs the agent with its current configuration. See custom agents.

Want to see the exact snippet before connecting? Try the agent config generator.

Connection parameters for other clients

Any client that lets you bring your own key can use AutoJev. Open Connection parameters to copy:

The local gateway does not authenticate the key. If you enter a client name, it becomes the key suffix (for example autojev-local-my-script) so requests are labelled in Logs. Snippets are available as env, JSON or cURL:

OPENAI_BASE_URL=http://127.0.0.1:9527/v1
OPENAI_API_KEY=autojev-local-my-script

curl http://127.0.0.1:9527/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer autojev-local-my-script' \
  -d '{"model":"autojev/fast","messages":[{"role":"user","content":"Hello"}]}'

curl http://127.0.0.1:9527/v1/messages \
  -H 'Content-Type: application/json' \
  -H 'x-api-key: autojev-local-my-script' \
  -H 'anthropic-version: 2023-06-01' \
  -d '{"model":"autojev/fast","max_tokens":1024,"messages":[{"role":"user","content":"Hello"}]}'

Gateway endpoints

The gateway listens on localhost only.

Protocol conversion and limits

AutoJev separates the protocol an agent speaks from the API type of the upstream model. All six directions among Chat Completions, Responses and Anthropic Messages are supported.

Converted: system instructions, text, images (URL and base64), function tools and tool calls, Responses custom tools, streaming text and tool arguments, usage and errors. Structured output is converted between Chat Completions and Responses only.

Limits:

• Conversion cannot add vision, tool use, reasoning or context capacity to a model that lacks them.
• previous_response_id, conversation, hosted tools such as web search, audio and file content are rejected when converting. Use a native upstream for those.
• Provider-specific thinking blocks, encrypted reasoning and signatures are dropped.
• The Gemini bridge supports text, inline images and function calls. Streaming buffers the upstream completion and emits one event; token counts are estimates.

Read more in protocol conversion.

Failover settings

Named load-balancing and intelligent routes fail over to the next candidate before any output starts on connection errors and HTTP 401, 402, 403, 408, 429 and 5xx. Each candidate is tried at most once. HTTP 400 and 422 are not retried, and a response that has started streaming is never replayed.

Configure these under Settings → Gateway & routing → Failover and timeouts:

401, 402, 403 and 429 put a channel into cooldown immediately, and Retry-After from the upstream is respected. After cooldown, one probe request is allowed through before the channel is marked healthy again. Channel health shows the current state and can be reset.

Outbound proxy: choose Direct connection, System proxy or Custom proxy. Stop the gateway before changing the proxy or connection timeout. See failover and load balancing.

Debug console

Debug sends real requests through the gateway in Conversation mode or cURL mode. Switch the API type, attach up to four files (4 MB each), add custom parameters, and inspect the selected model, timing, tokens, estimated cost and raw JSON. Live tests may incur provider costs. See debug console.

Logs and usage

• Logs — filter by date range, agent, provider and status, or search. Columns include time and agent, model and provider, route ID, input/output/cache tokens, first byte and total time, estimated cost and status. The detail view lists every upstream attempt. The list refreshes every 5 seconds.
• Usage — requests, input and output tokens, cache read and write, cache hit rate, estimated cost, success rate and average duration, with a daily token chart and breakdowns by agent, model and provider.

Costs are estimates based on the prices you configure and the usage providers return. See usage and logs and the LLM cost calculator.

Privacy and data

• Configuration and provider keys are stored locally in ~/.autojev/autojev.db (SQLite). Development builds use autojev-dev.db. Keys are currently stored unencrypted, so protect this file like any other credential store.
• Request logs store metadata only: model, status, timing, usage and estimated cost. Full prompts, responses and API keys are not persisted in request logs.
• There is no AutoJev account and no AutoJev cloud relay. Model requests go directly from your machine to the provider you selected, and AutoJev adds no markup.
• When a route uses intelligent selection with the balanced or quality preference, only routing metadata is sent to the Jev decision model.
• Connecting an agent edits its configuration file and creates a backup. Do not commit real configurations, databases, keys or backups to a repository.

Lifecycle: pause, stop, tray

• Closing the window keeps AutoJev and the gateway running in the tray or menu bar. On macOS the Dock icon is hidden while the window is hidden.
• Pause service keeps agent configurations in place and rejects new requests with HTTP 404 and error code gateway_paused. Requests already in progress can finish.
• Stop and restore configurations restores every connected agent's configuration, then shuts down the gateway.
• The tray menu offers Open AutoJev and Quit AutoJev (restore agents).
• On the next launch, AutoJev reconnects agents according to your saved preferences. Agents you disconnected manually stay disconnected.

Updates

Release builds check for updates at startup and every four hours. Updates are signature-verified before installation, and AutoJev offers a restart once installation succeeds. Turn off automatic checks in Settings → General, or check manually in Settings → About. Let active agent requests finish before installing an update.

Build from source

Requires Node.js 22+, pnpm 10+, stable Rust and the Tauri prerequisites for your platform.

git clone https://github.com/thinkany-ai/autojev.git
cd autojev
pnpm install --frozen-lockfile
pnpm dev

Development builds use a separate app identifier, database and port (9526) and do not check for release updates. Tests:

pnpm test
pnpm build
cargo test --locked --manifest-path src-tauri/Cargo.toml --lib

AutoJev is open source under the MIT license, © ThinkAny, LLC. You can use, modify and redistribute it, including commercially, as long as you keep the copyright and license notice.

Troubleshooting and FAQ

My agent still talks to its old provider. Check the agent's connection status in Agents, then restart the agent — many agents read configuration only at startup.

Requests fail with gateway_paused. The service is paused. Resume it in AutoJev.

A Codex request fails with an unsupported feature. Codex uses the Responses API. Features such as previous_response_id or hosted web search cannot be converted to a Chat Completions or Messages upstream. When connecting Codex, AutoJev sets web_search = "disabled" for this reason. Use a model whose API type is responses if you need those features.

Thinking or reasoning disappears when I use a converted model. Provider-specific thinking blocks are not portable and are dropped during conversion. Use the model's native protocol if your workflow depends on them.

Intelligent routing always falls back to load balancing. Check Settings → Gateway & routing → Decision model and click Test Jev. The request log records the fallback reason (missing key, timeout, low confidence or unknown candidate).

Speed routing does not pick the model I expect. Speed routing uses up to five samples from the last 30 minutes. Run a speed test or enable scheduled tests; without comparable measurements, requests use weighted load balancing.

How do I undo everything? Use Stop and restore configurations, or quit from the tray with Quit AutoJev (restore agents). Each connected agent's original configuration is restored.

Does AutoJev support Cursor? Cursor CLI is detected, but it does not expose a documented custom model endpoint, so AutoJev cannot route its requests.

Does AutoJev manage MCP servers or Skills? No. AutoJev manages providers, models, routes and agent model connections.

Where can I report a problem? Open an issue on GitHub.