跳到正文Skip to content
Agent J Beta
菜单Menu
中文EN
登录Sign in

搜索文档和页面Search docs and pages

文档Docs

换 AI 编程工具：先检查，能用才切Switch AI coding tool — checked first, switched only if it works

在手机菜单里发换 AI 工具的命令，主 Agent 先解释、扫描这台电脑上的 Claude Code、Codex、OpenCode，并用无头方式试一下各自的登录；能用的才切，切完新工具先自报家门，不通就自动切回。Send the switch command from the phone menu; your main Agent explains, scans this computer for Claude Code, Codex and OpenCode, tries each sign-in headless, switches only to one that works, and the new tool introduces itself — or Agent J switches back by itself.

AI 编程工具就是这台电脑上真正动脑子、动手干活的那个程序：Claude Code、Codex 或 OpenCode。Agent J 是你手机通往它的那条线。换工具，换的是谁来回答你；工作目录、手机、审批和安全规则都不变。

怎么发起

  • 在输入框左边的 ≡「全部命令」里，「一键执行」一组（/customize 下面）有一条换 AI 工具的命令（/switch-harness），点一下就发给主 Agent。想直接说切到哪个，也可以在输入框里打这条命令，后面补一句「切换到 Codex」再发。
  • 或者直接说「切换到 OpenCode」「切回 Claude Code」。

点了不会马上切换。这条命令交给现在的主 Agent，由它按一套固定流程来做。

主 Agent 会怎么做

  1. 先说明。 你什么都没补就发过来，它会先用两三句话解释它说的是哪种工具，再告诉你接下来怎么切。
  2. 扫描。 看这台电脑装了哪几个 AI 编程工具、各是什么版本。
  3. 试登录。 对每个装了的工具，用你自己的登录、用它切过去后会用的模型，做一次很小的无头调用（不带任何工具权限，每个最多 60 秒），看它现在能不能正常回答。这一步在电脑上的一个独立小任务里做，用的是 Agent J 后台服务的环境，也就是切过去以后那个工具真正会拿到的环境。只读：不改配置，不读出、不显示任何密钥。
  4. 告诉你结果。 比如「现在能切到：Codex、OpenCode」，或者「这台电脑只有现在这一个能用，没法切换，要切得先装一个别的」。装了却用不了的，会说明原因：没登录、token 失效，或者网络 / 代理不通。
  5. 帮你装、教你登。 没装的，你同意后它按 安装 AI 命令行工具 帮你装。登录要你自己来，它会一步步告诉你在自己的终端里运行什么、会看到什么、该点哪里：Claude Code 是 claude auth login，Codex 是 codex login，OpenCode 是 opencode auth login。模型的 API key 不进聊天，走手机上的密钥卡。装好、登好，它会再试一次。
  6. 切换。 只有目标刚刚试通、你也明确要切，它才动手。

切换时会发生什么

主 Agent 先跟你说一句：Agent J 会重启，手机断开几秒后自动连上。然后它运行 agentj agent switch <目标>：

  • 这条命令会再试一次目标的登录，这是最后一道闸。试不通就什么都不改，主 Agent 会告诉你原因。
  • 试通了，切换交给电脑上一个独立的小任务：等这一轮说完，换成新的工具，重启 Agent J，然后检查新的工具起来没有、能不能回答。
  • 换 Codex 时，这道闸还会按切换后的样子把它的长驻会话先打开一次：同一个工作目录，用你自己的 Codex 设置和里面的 MCP 服务器、插件（不会在你的 Codex 历史里留下会话，也不发任何消息）。打不开就什么都不改，并告诉你原因；打开得慢，切换后就相应多等它一会儿。
  • 重启后，新的工具只要还在启动，就会继续等，最多 8 分钟。还是不说话的话，agentj agent switch --result 和切回后的说明会讲清它停在哪一步：还在启动、卡在终端里的确认提示、在等手机上的批准卡、启动失败，或者已经起来但一直不说话；有报错会说报错类型，并告诉你下一步怎么做。
  • 一切正常，新的工具会先跟你打招呼，说它是谁、用的什么模型。
  • 任何一步不通，Agent J 会自动切回原来的工具，原样恢复之前的设置，再由原来的那个告诉你没切成、为什么。

所以就算你不在电脑前、不会用终端，也不会因为切到一个不能用的工具而失联。

切换前先写交接

每个工具有自己的对话，新的那个看不到你们刚才聊了什么。所以切换前，Agent J 先让现在这个工具按和压缩交接一样的格式写一份交接文件；切过去以后，新的工具先读它，再接着干。

  • 交接在检查通过之后、真正切换之前写。只留要点：你的原话要点、进度、已经定下的决定、关键路径和命令、踩过的坑、下一步、等你回答的问题；不超过 150 行，不写任何密钥、token、密码。
  • 文件位置固定：独立会话在 <工作目录>/.agentj/handover/switch.md，共享会话在 ~/.local/state/agentj/handoff/switch.md。切回来也一样：离开的那个写，接上的那个读，同一份文件合并更新。
  • 新的工具接上后先读交接，再跟你打招呼，说它接上了什么；然后 Agent J 让它按交接里的「下一步」接着干。交接里没有进行中的事，它就等你发话。
  • 最多等 3 分钟。没写成也照样切换：手机上会说「这次没写成交接」，新的工具也会告诉你它不知道之前说过什么，要点可能得再说一遍。

切过去，也要切得回来

  • 切换前，除了试目标，还会用同样的办法试一下现在这个工具。现在这个在后台服务里试不通（比如它的登录只放在你终端的环境变量里），切过去以后就切不回来了，所以默认不切，并告诉你怎么先把它修好。你确定要切，可以加 --force。
  • 已经切过去、想回去却过不了检查时，在电脑上运行 agentj agent switch --undo（或者让主 Agent 运行）：不再预检，直接原样换回上一次切走前的那个；换回去起不来，会自动回到现在这个。
  • 后台服务找不到 Claude Code 的登录时，会直接告诉你怎么办：在终端运行 claude，输入 /login 登录一次（Mac 上登录存进钥匙串，后台也能用）；或者在能用 claude 的终端里运行 agentj service import-key CLAUDE_CODE_OAUTH_TOKEN，再运行 agentj service restart。
  • 工具自己升级过（比如 Codex 从 0.156 升到 0.162），后台服务以前记下的旧版本路径会自动作废，改用你终端里找到的那个，扫描结果里会写明。

切换不用管理员密码

不管现在是哪个工具在干活，包括在隔离里运行的 OpenCode、Kimi Code、Qwen Code，切换、扫描和 --undo 都交给 Agent J 自己的后台服务去做：不用管理员密码，也不用你回电脑前开终端。

  • Agent 要是说「后台服务没加载」，要你输管理员密码，或者让你去终端运行 agentj service start，不用照做。它在隔离里看不到系统的服务管理器，才会以为服务停了。
  • 想确认服务在不在运行，就运行 agentj service status。它直接问正在运行的服务本身，有应答就显示「后台服务在运行（serve 在应答）」。
  • Agent J 也不会为管理它自己的后台服务弹管理员密码卡，这种请求会被直接拒绝。

OpenCode 没有 key 也能用

  • OpenCode 自带几个免费模型（opencode/…，名字多半以 -free 结尾），不用注册、不用 key、不用付钱。用的是这种模型时，没有 key 也算能用；切过去写成 agentj agent switch opencode --model opencode/<免费模型>，opencode models opencode 列出现在有哪些（几乎每天在变）。
  • 免费模型的检查走和正常聊天同一条路（OpenCode 会拒绝不像它自己客户端的请求）；刚装好的头一两分钟偶尔被拒，检查会自己等一会儿再试，最多多花一分钟多。
  • 有几个免费模型的服务商会记录对话或拿去训练模型，选中它们时切换结果和手机「模型和 API Key」卡上会多一句提示。别在里面发个人或机密信息；长期用建议换成你自己的模型。
  • 切换写进设置后，切换任务会把设置读回来核对一遍，对不上就不切。

等的时候手机上看到什么

扫描最多要三分钟左右，切换还得重启一次。这段时间回复卡不会空着：正文开头是个跳舞的小机器人，后面跟着 Agent J 自己写的进度——正在探测哪一个（第几个、共几个）、正在切换到哪一个，或者已经切回原来那个、它马上说明原因。机器人还在跳，就说明消息没丢、进程没断。

几件要知道的事

  • 每个工具有自己的对话记录。切过去是那边的对话，切回来接着原来的。
  • 隔离、共享会话还是独立会话、工作目录、审批规则，切换都不改。
  • 共享模式下，新的工具要有可以接上的会话：Claude Code 要在电脑上开着；Codex 和 OpenCode 没有开着的会话时，会在同一个目录里新开一个。
  • 电脑上的 Codex 对话如果是只读权限，它运行不了切换命令，会把 Codex 的拒绝原话告诉你；那条对话要改成「完全访问」才行。
  • 想看上一次切换的结果，在电脑上运行 agentj agent switch --result，或者问主 Agent。
agentj agent switch --scan
agentj agent switch codex --dry-run

第一条看现在能切到哪些（用后台服务的环境逐个试）；第二条只检查能不能切到 Codex，不切。

换成 Kimi Code

Kimi Code CLI（kimi，月之暗面出品，MIT 开源，2.2.0 或更新）是 Agent J 能切换的第四个 AI 编程工具。在用不了 Claude Code 和 Codex 的地方（中国大陆、香港、澳门），它是常见的选择。Agent J 通过 Agent Client Protocol（kimi acp）跟它对话：每个 Agent 一段长驻对话，回复整段发到手机，每次审批都在你手机上。

  • 切换：agentj agent switch kimi；在海外站 kimi.ai 买的会员加 --region global。先检查、写交接、不通自动切回，这些和别的工具一样。Kimi Code 只支持独立会话（暂时不能接电脑上开着的终端会话）。
  • 手机上登录：设置 → 紧急修复 → ③ AI 账号登录失效 → AI 登录救援 → Kimi Code →「重新登录（设备码）」。电脑运行官方的 kimi login，手机上显示一个链接和一次性设备码，你在任何登录了 Kimi 的设备上确认就行。在电脑上登录是 kimi login --region mainland-cn（国内站 kimi.com，默认）或 kimi login --region global（海外站 kimi.ai）。kimi.com 会员的 key 在 api.kimi.com 和 api.kimi.ai 两个地址都能用。
  • 也可以用 Kimi Code 控制台的 API key：让 Agent 发手机密钥卡存 KIMI_API_KEY，不要把 key 发在聊天里。只有 Kimi 自己没登录时，Agent J 才把这把 key 在内存里交给它。
  • 审批权在你手里。Kimi 自己的 hook 出错或超时会默认放行，所以 Agent J 不依赖它：每段 Kimi 对话都固定在 Kimi 的手动审批模式，每个权限请求都变成手机卡片，你点同意只算这一次，绝不是以后都同意。Kimi 要是自己切到 Auto 或 YOLO 模式，Agent J 会马上切回来。Kimi 没有自带沙箱：它在 Agent J 的隔离里运行，危险命令拦截强制打开。你自己在 ~/.kimi-code/config.toml 里写的放行规则还是你的，agentj doctor 会告诉你有几条。
  • 技能：Kimi 读 ~/.agents/skills，Agent J 的随包技能本来就链接在那里，直接能用。广场里的包给 Kimi 装的是 Codex 版。
  • 想用 OpenCode 接 Kimi 模型？那条路线还在，agentj agent route 两种都会给。

换成 Qwen Code

Qwen Code（qwen，阿里出品，Apache-2.0 开源，0.25 或更新）是 Agent J 能切换的第五个 AI 编程工具，在中国大陆和阿里百炼 Token Plan 正好配成一对（怎么配）。Agent J 和它对话用的也是 Agent Client Protocol（qwen --acp），和 Kimi Code 一样。

  • 切换：agentj agent switch qwen。先检查、写交接、不通自动切回，这些和别的工具一样。只支持独立会话。
  • 它的免费登录 2026-04-15 已经停了，key 就是它的登录：让 Agent 发手机密钥卡存 BAILIAN_TOKEN_PLAN_API_KEY。Agent J 只在内存里把 key 交给 Qwen Code；你自己配过 ~/.qwen/settings.json 的，以你的为准。
  • 审批权在你手里。Qwen Code 默认的模式会让一个分类器自己批准一部分操作；Agent J 把每段对话都切回「每次都问」，每个请求都变成手机卡片，只批这一次。
  • 手机上的 /model 列出套餐里的模型，名字后面带“看图”两个字的能读截图。换模型会重启 Qwen Code，接着原来的对话。
  • 你自己的定时任务也可以用 Token Plan 的 key（长时间连续跑的后台任务服务商可能限流，可改用按量付费的 key）；客服 bot 是在服务别人，Agent J 不会把这把 key 交给 bot。

换成 DeepSeek dsh

dsh（DeepSeek Harness，DeepSeek 出品，MIT 开源，0.2.0-rc.2 或更新，还是开发者预览版）是 Agent J 能切换的第六个 AI 编程工具。Olares 自带的 Agent「Lares」用的就是它；它也能接任何 OpenAI 兼容的模型服务（怎么配）。Agent J 和它对话用的也是 Agent Client Protocol（dsh --profile acp），和 Kimi Code 一样。

  • 切换：agentj agent switch dsh。先检查、写交接、不通自动切回，这些和别的工具一样。只支持独立会话。
  • 还没配模型？检查结果会告诉你。运行 agentj agent dsh --base-url https://<服务>/v1 --model <模型 id> 配一条，key 只走手机密钥卡（DSH_ROUTER_API_KEY；DeepSeek 官方 API 用 DEEPSEEK_API_KEY）。你自己配过 dsh 的，按你的来。
  • 审批权在你手里。Agent J 让 dsh 以只读方式启动，每次都问：改文件、跑不是只读的命令，每一个都变成手机卡片，只批这一次，没有「总是允许」。
  • 手机上的 /model 列出路线里的模型和 DeepSeek 的模型，/context 也能用。对话快满时 dsh 会自己压缩（它没有 /compact）。用你自己的模型服务，就没有套餐额度一说。
  • 暂时只能读文字。定时任务也能用它，但拿不到密钥卡里的 key。

An AI coding tool is the program on this computer that actually thinks and does the work: Claude Code, Codex or OpenCode. Agent J is the line from your phone to it. Switching changes who answers you; the work folder, the phone, approvals and the safety rules stay the same.

How to start

  • In ≡ "All commands" left of the message box, the "Run now" group (under /customize) has the switch command (/switch-harness); one tap sends it to your main Agent. To name the target yourself, type the command in the box, add "switch to Codex" after it and send it.
  • Or just say "switch to OpenCode" or "back to Claude Code".

Nothing switches when you tap it. The command goes to your current main Agent, which follows a fixed procedure.

What your main Agent does

  1. Explains. If you sent the command with no words, it first says in two or three sentences which kind of tool it means and how to switch.
  2. Scans which AI coding tools this computer has, and their versions.
  3. Tries each sign-in. For every installed tool it makes one tiny headless call with your own login and the model the tool would run with (no tool permissions, at most 60 seconds each) to see whether it answers now. This runs in a separate small job on the computer, in the environment of Agent J's background service — exactly what the tool gets after a switch. Read-only: no config is changed, no key is read out or shown.
  4. Tells you, for example, "you can switch to: Codex, OpenCode" — or "only the current one works on this computer; to switch, install another one first". For an installed one that does not work it says why: not signed in, an expired token, or no network / proxy.
  5. Helps install, guides the sign-in. With your yes it installs a missing one following Set up AI command-line tools. Signing in is yours: it tells you step by step what to run in your own terminal, what you will see and what to click — claude auth login for Claude Code, codex login for Codex, opencode auth login for OpenCode. A model API key never goes through the chat; it uses the masked key card on your phone. Then it tries again.
  6. Switches only to a target that just passed, and only when you clearly ask.

What happens during the switch

Your main Agent first says: Agent J restarts, the phone disconnects for a few seconds and reconnects by itself. Then it runs agentj agent switch <target>:

  • The command tries the target's sign-in once more — the last gate. If it fails, nothing changes and your Agent tells you why.
  • If it passes, a separate small job on the computer takes over: it waits for the current reply to finish, switches, restarts Agent J and checks that the new tool is up and answers.
  • For Codex the gate also opens its long-running session once, the way it will run after the switch: the same work folder, your own Codex settings with their MCP servers and plugins (nothing is kept in your Codex history, no message is sent). If that session cannot open, nothing changes and you get the reason. If it opens slowly, the switch waits for it accordingly.
  • After the restart, a tool that is still visibly starting is waited for, up to 8 minutes. If it still says nothing, agentj agent switch --result and the switch-back message say where it stopped — still starting, waiting at a prompt in a terminal, waiting for an approval card, failed to start, or started but silent — plus the error type if it printed one, and what to do next.
  • When all is well, the new tool greets you first: which one it is and which model it runs.
  • If any step fails, Agent J switches back to the previous tool by itself, restores the earlier settings exactly, and the previous one tells you it did not work and why.

So even away from the computer, without a terminal, you cannot be cut off by switching to a tool that does not work.

A handoff before every switch

Each tool keeps its own conversation, so the new one cannot see what you just talked about. Before switching, Agent J has the tool you use now write a handoff file in the same format as the compaction handoff; after the switch the new tool reads it first, then carries on.

  • The handoff is written after the checks pass and right before the switch. Only the essentials: your key points in your own words, progress, decisions already made, key paths and commands, pitfalls, the next step and questions waiting for you; at most 150 lines, never a key, token or password.
  • Fixed places: <work folder>/.agentj/handover/switch.md for an independent session, ~/.local/state/agentj/handoff/switch.md for a shared one. Switching back works the same way: the one leaving writes, the one taking over reads, and the same file is merged and updated.
  • The new tool reads the handoff before it greets you and says what it picked up; then Agent J has it carry on with the handoff's next step. If nothing was in progress, it waits for you.
  • Agent J waits at most 3 minutes. If no handoff was written the switch still happens: the phone says "No handoff this time", and the new tool tells you it does not know what was said before, so the key points may need repeating.

Switching there means being able to come back

  • Before switching, the tool you use now is tried the same way as the target. If it fails in the background service (for example because its login lives only in your terminal's environment), there would be no way back after the switch, so by default nothing is switched and you are told how to fix it first. To switch anyway, add --force.
  • Already switched and the check will not let you go back? Run agentj agent switch --undo on the computer (or ask the main Agent to): with no pre-check it restores the tool from before the last switch exactly as it was; if that one does not come up, Agent J returns to the current one by itself.
  • When the background service finds no Claude Code login, it says what to do: run claude in a terminal and /login once (on a Mac the login goes to the Keychain, which the service can use too), or in a terminal where claude works run agentj service import-key CLAUDE_CODE_OAUTH_TOKEN, then agentj service restart.
  • When a tool has updated itself (say Codex from 0.156 to 0.162), an older path the background service had saved is dropped and the one your terminal finds is used; the scan says so.

Switching never needs the admin password

Whichever tool is working now, including OpenCode, Kimi Code and Qwen Code running inside the isolation, switching, scanning and --undo go through Agent J's own background service: no admin password, and no need to go back to the computer and open a terminal.

  • If your Agent says "the service is not loaded" and asks for the admin password, or asks you to run agentj service start in a terminal, you don't need to. Inside the isolation it can't see the system's service manager, so it may think the service has stopped.
  • To check whether the service is running, run agentj service status. It asks the running service itself and says it is running whenever the service answers.
  • Agent J never asks for the admin password to manage its own background service either; such a request is refused.

OpenCode with no key

  • OpenCode comes with a few free models of its own (opencode/…, mostly ending in -free): no account, no key, no payment. With one of them OpenCode counts as usable without a key; switch with agentj agent switch opencode --model opencode/<free-model> — opencode models opencode lists the current ones (they change almost daily).
  • A free model is checked on the same path as a normal chat (OpenCode refuses requests that do not look like its own client); in the first minute or two after installing it is sometimes refused, and the check waits and retries by itself — at most a minute or so longer.
  • Some free models' providers log the conversation or train on it: when you pick one, the switch result and the phone's "Models & API keys" page add one sentence saying so. Keep personal or confidential things out of it, and use a model of your own for everyday use.
  • After writing the setting, the switch job reads it back; if it does not match, nothing is switched.

What the phone shows while you wait

A scan can take about three minutes, and a switch restarts Agent J once. The reply card is never blank meanwhile: its text starts with a small dancing robot followed by Agent J's own progress line: which tool it is probing (and which of how many), which one it is switching to, or that it is back on the previous one, which will tell you why in a moment. As long as the robot dances, your message is not lost and nothing has stopped.

Good to know

  • Each tool keeps its own conversation. After a switch you are in that one's conversation; switching back continues the earlier one.
  • Isolation, shared or independent session, the work folder and the approval rules are unchanged by a switch.
  • In shared mode the new tool needs a session to attach to: Claude Code must be open on the computer; Codex and OpenCode start a new one in the same folder when none is open.
  • A Codex conversation that is read-only cannot run the switch command; your Agent tells you Codex's refusal — that conversation needs Full access.
  • To see the last switch's outcome, run agentj agent switch --result on the computer, or ask your main Agent.
agentj agent switch --scan
agentj agent switch codex --dry-run

The first shows which ones you can switch to now (each tried in the background service's environment); the second only checks whether Codex would pass, without switching.

Kimi Code

Kimi Code CLI (kimi, by Moonshot AI, MIT licence, 2.2.0 or newer) is the fourth AI coding tool Agent J can switch to — a common choice where Claude Code and Codex are not offered (mainland China, Hong Kong, Macau). Agent J talks to it over the Agent Client Protocol (kimi acp): one long-running conversation per Agent, replies in whole pieces, every approval on your phone.

  • Switch with agentj agent switch kimi; a membership bought on kimi.ai adds --region global. The same check-first gate, handoff and automatic switch-back apply. Kimi Code runs in an independent session only (no shared terminal session yet).
  • Sign in from the phone: Settings → Emergency repair → ③ AI account signed out → AI login rescue → Kimi Code → Sign in again (device code). The computer runs the official kimi login, the phone shows a link and a one-time code, and you confirm on any device signed in to Kimi. At the computer it is kimi login --region mainland-cn (kimi.com, the default) or kimi login --region global (kimi.ai). A key from a kimi.com membership works on both api.kimi.com and api.kimi.ai.
  • A Kimi Code console API key works too: the Agent sends a phone key card for KIMI_API_KEY — never paste it into the chat. Agent J hands it to Kimi in memory, and only when Kimi has no login of its own.
  • Approvals stay with you. Kimi's own hooks let a call through when they fail or time out, so Agent J does not rely on them: every Kimi conversation is kept in Kimi's manual mode, each permission request becomes a phone card, and a yes covers this one call only, never later ones. If Kimi switches itself to Auto or YOLO, Agent J switches it straight back. Kimi has no sandbox of its own: it runs inside Agent J's isolation, with its dangerous-command guard forced on. Allow rules you wrote yourself in ~/.kimi-code/config.toml stay yours; agentj doctor says how many there are.
  • Skills: Kimi reads ~/.agents/skills, where Agent J already links its bundled skills, so they work unchanged. A plaza package installs its Codex version for Kimi.
  • Prefer OpenCode with a Kimi model? That route stays; agentj agent route offers both.

Qwen Code

Qwen Code (qwen, by Alibaba, Apache-2.0, 0.25 or newer) is the fifth AI coding tool Agent J can switch to, a natural pair with an Alibaba Cloud Bailian Token Plan in mainland China (setup). Agent J talks to it over the same Agent Client Protocol as Kimi Code (qwen --acp).

  • Switch with agentj agent switch qwen. The same check-first gate, handoff and automatic switch-back apply. Independent sessions only.
  • Its free sign-in ended on 2026-04-15, so a key is its login: the Agent sends a phone key card for BAILIAN_TOKEN_PLAN_API_KEY. Agent J hands the key to Qwen Code in memory only; your own ~/.qwen/settings.json, if you set one up, wins.
  • Approvals stay with you. Qwen Code starts in a mode where a classifier approves some actions by itself; Agent J switches every conversation back to asking, and each request becomes a phone card for that one action.
  • /model on the phone lists the plan's models; those marked as reading images can look at screenshots. Changing the model restarts Qwen Code and continues the same conversation.
  • Your own scheduled tasks may use the Token Plan key too (the provider may rate-limit long, continuous background work; you can switch those to a pay-as-you-go key); a support bot serves other people, so Agent J never gives it that key.

DeepSeek dsh

DeepSeek's dsh (DeepSeek Harness, MIT, 0.2.0-rc.2 or newer, a developer preview) is the sixth AI coding tool Agent J can switch to. It is the engine inside Olares' own agent Lares, and it works with any OpenAI-compatible model server (setup). Agent J talks to it over the same Agent Client Protocol as Kimi Code (dsh --profile acp).

  • Switch with agentj agent switch dsh. The same check-first gate, handoff and automatic switch-back apply. Independent sessions only.
  • No model yet? The check says so: agentj agent dsh --base-url https://<server>/v1 --model <model id> sets one up. A key goes only through the phone key card (DSH_ROUTER_API_KEY, or DEEPSEEK_API_KEY for DeepSeek's own API). Your own dsh setup, if you have one, is used as it is.
  • Approvals stay with you. Agent J starts dsh read-only, asking every time: each file change or command that is not read-only becomes a phone card for that one action, never "always".
  • /model on the phone lists the route's model and DeepSeek's models; /context works. dsh compacts its own conversation when it gets near the limit (there is no /compact for it). A model server of your own has no plan quota.
  • It reads text only for now. Scheduled tasks may use it, but never get a key from the key card.

这一页的 Markdown 原文This page as Markdown: zh.md · en.md