AdaptiqAI for DeepSeek Harness

Use your AdaptiqAI workspace in DeepSeek Harness: every model in your workspace, with native memory that keeps the whole conversation — up to 5 million tokens — and your Knowledge collections in any conversation. You sign in once, or create your account, in the browser; then pick a model and start, all from inside the harness. There are no keys to copy.

Install

Needs DeepSeek Harness 0.2.0-rc.2 or a later 0.2 release.

1. Open Plugins in the sidebar and choose Add plugin.
2. Enter the package — @adaptiqai/deepseek-harness, or the full path to a downloaded adaptiqai-deepseek-harness-<version>.tgz — and install it.
3. A welcome card asks you to Connect AdaptiqAI. Your browser opens; you sign in (or create an account with GitHub, Google or email) and approve, and the harness picks it up by itself.
4. A new account has no model yet: the same card shows the models on offer, with price, speed and memory. Choose one and how many conversations can run at once, then Get access and confirm in the browser. The model appears in the picker as soon as it is active.

In the DeepSeek Harness desktop app, use the Plugins page; it keeps its own profile, which the dsh command can't change. If you run dsh web from a terminal, the same install is:

dsh plugin --profile web add @adaptiqai/deepseek-harness

What you get

Your models, set up correctly. The model picker gets an AdaptiqAI group with exactly the models in your workspace. Each one comes with its real context window, its output limit and its own thinking levels, all read from the server — nothing in the plugin names a model.

Memory you can see. A small pill next to the send button shows what the model sees now: the conversation's memory against the model's window (Memory · 25k / 5M). It never adds up over a turn. After each answer it shows how much came straight from memory (24.6k from memory). Click it to switch the conversation between Remember and Private, add or remove knowledge, and see Processed: new input, read from memory, saved to memory and output, with the cost, for the last turn and the whole conversation. Every agent step reads the whole memory again, so these grow far past the memory's size; they are the same four numbers DeepSeek Harness's own usage panel counts (its uncached input, cached input, cache write and output). The plugin counts them on this computer from each answer's usage and keeps them across restarts.

Settings → AdaptiqAI. Your workspace, the models with live running/waiting counts, memory use split into conversations and knowledge, whether new conversations are saved, and links to the console.

Knowledge. The Knowledge panel in the sidebar lists your collections. Use one in the open conversation with one click, or drop files to create a new collection; it is attached automatically when it is ready.

One model per memory. AdaptiqAI builds a conversation's memory and each collection for one model, and they only work with that model. The Knowledge panel lists the collections that work with the model you are using first. Collections built for other models appear below, greyed out, each with Make available for . A collection can never be added to a conversation on the wrong model. If you switch the model in a conversation whose memory is on another model, a short note above the composer offers Switch back or Start fresh on .

Notices that say what to do. If a model is busy, the harness waits and retries by itself and tells you so. If a model isn't in the workspace yet, you get a Get access button. If the balance runs out, you get an Add funds button. If memory is nearly full, you are told before it fills, with a way to clean up or continue privately. Where AdaptiqAI puts idle conversations to sleep to make room, one quiet line says so instead: nothing is deleted, and they wake when you use them. Then you are only told when nothing idle could sleep or your library is full, with a button to the console. If your sign-in expires, you are asked to sign in again.

Updates in one click. When a new AdaptiqAI release is out, a notice offers Update: the plugin installs it through the Plugins page's own installer and switches to it, without a restart where the harness allows. pnpm normally waits a day before it installs a new version; so that the update installs at once, the plugin first lists exactly that version of @adaptiqai/deepseek-harness under minimumReleaseAgeExclude in the profile's pnpm-workspace.yaml, replacing the version it listed before. Other packages keep pnpm's wait. If that file is laid out in a way the plugin can't edit safely, it is left alone and the update is offered a day after release, as before.

/adaptiq in the composer: status, signin, private, remember, knowledge, open, diagnostics, signout.

Get a model without leaving the harness. Settings → AdaptiqAI → Get a model (or Get access on any notice that offers it) lists what is on offer. You pay per token from your balance, and reads from memory are free. You confirm in the browser; the plugin follows the request and shows the model when it is ready.

Conversations as knowledge. Type @ in a message and pick another conversation: if it is on the same model, it is added to this conversation from memory (the model does not read it again as text), and it stays added for later messages. The memory pill says what was added. Or open the memory pill and choose Add: two tabs, Knowledge (your collections, newest first, the ones made in the last days marked New, the ones made for another model greyed with Make available here) and Conversations (recent ones on this model, named as in the sidebar); everything shows without typing, one click adds or removes. What a conversation uses shows as chips above the message box, × to stop using one, also before the first message. A private conversation adds nothing; a conversation you mention there is read as text.

Agent tools. Agents can find and attach knowledge, and find words, ids or names in the text of the collections a conversation uses, with the exact lines as document:line (adaptiq_knowledge). The first step of a turn is told which ready collections its conversation reads, once and again when they change, as a context row in the conversation, so the agent looks things up there. Agents can also check shared memory and offer clean-up options (adaptiq_memory), and save what they learned as a new collection (adaptiq_create_knowledge). After reading a sizeable set of files, or when you say remember, save, collection or NCM, the agent searches your knowledge and offers to save the material as a collection; on your yes it creates it and confirms in one sentence, in your language. Its chip shows a quiet progress line while it compiles and a short notice says when it is ready. The agent never shows ids or technical status. If it saved something with a mistake, saving again corrects the same collection instead of making a second one, and it can take back a collection it made in this conversation in the last 15 minutes; it never deletes anything else. The whole journey, with what still needs the server, is in docs/CONTEXT_MANAGEMENT.md.

How it works

• Requests go to the AdaptiqAI OpenAI-compatible API. Each request carries the harness conversation id (X-Adaptiq-Session-Id), so the server keeps one memory per conversation. Title requests carry no id, so they never fork a saved conversation.
• Subagents and teammates also name the conversation that started them (X-Adaptiq-Parent-Session-Id), so the console shows them under it. A subagent is a helper of its parent; an Agent Teams teammate is a track, a line of work of its own (X-Adaptiq-Session-Role). A conversation you fork yourself names no parent.
• No compaction. AdaptiqAI keeps the full conversation, so the plugin reports the model's true context window and declines the harness's compaction requests — in Remember and in Private — with a plain explanation, said once rather than at every step. Nothing is ever summarised away, and nothing is sent to the server for it.
• Thinking levels come from each model's capability card (adaptiq-model-capabilities-v1): the levels, the value that turns thinking off, the default and the request field. Models without a card fall back to Low/High/Extra high/Max only when their id names a reasoning model.
• Images reach a model whose capability card lists image in input: each one goes inline (image_url with a data: URL) where you put it in the message, after a short note naming it. The bytes come from the harness's own stored copy (content-addressed when you attached it), never from the original file, so a later turn resends exactly the same image even if the file changed. Images larger than 16 MP are scaled down first; the format is checked from the bytes (PNG, JPEG, WebP, GIF), and an image over 20 MB is refused with a plain message. Above 8 images in one request, the harness turns the oldest into notes. A model that reads text only gets a note in place of each image, and a notice says the images were not sent. Images a tool returns follow its result in the next message.
• Usage is reported the harness's way: tokens read from memory count as cache reads, so the harness's own counters (cost, cache hit) are right.
• Busy and preparing answers are retried by the harness, honouring the server's Retry-After.

Privacy and security

• Sign-in uses the device flow: the plugin shows a short code, you approve in the browser, and the plugin receives a workspace credential. It is stored in the harness credential store ($DSH_HOME/.credentials.yaml, readable only by you) and renews itself. Tokens never reach the browser page.
• The connection appears in the AdaptiqAI console under API keys as "DeepSeek Harness on "; revoking it there disconnects this computer only.
• Private conversations can still read memory and knowledge, but nothing new is saved.
• /adaptiq diagnostics produces a report without any secrets that you can send to support.

Headless and CI

Without a browser, store an API key from the console under the credential reference ADAPTIQAI_API_KEY (for example as an environment variable). The plugin uses it whenever no one is signed in.

Configuration

Everything has a production default. To change something, add a row to your profile's cordis.patch.yml:

- id: adaptiq
  name: '@adaptiqai/deepseek-harness'
  config:
    route: adaptiqai              # provider id in the model picker
    apiBase: https://api.adaptiqai.com
    consoleUrl: https://memory.adaptiqai.com/memory
    apiKeyEnv: ADAPTIQAI_API_KEY  # headless credential reference
    tools: true                   # agent tools
    progressEvents: true          # streamed "preparing" progress
    streamIdleTimeoutSeconds: 900

Troubleshooting

• "AdaptiqAI models are hidden — another provider already uses the route". An older hand-made adaptiqai provider exists in your profile (usually an llm-pi-ai entry in cordis.patch.yml). Remove that entry and restart the harness.
• Models missing. Open Settings → AdaptiqAI and press refresh; the list shows exactly the models in the workspace.
• Anything else: run /adaptiq diagnostics and send the report to support.

Development

pnpm install
npm install -g @deepseek-ai/[email protected]   # the harness release the plugin targets (as CI does)
npm run link-dsh      # link the installed DeepSeek Harness packages for types and tests
npm run build         # lib/index.js (Host), lib/client.js (browser), Typert artifacts
npm test              # unit tests
ADAPTIQ_LIVE=1 ADAPTIQAI_API_KEY=ak_live_… npx vitest run test/live.test.ts   # one short live request
npm run pack:local    # dist/adaptiqai-deepseek-harness-<version>.tgz

Layout: src/host (adapter, sign-in, workspace service, Remote controller, command, tools), src/client (React UI in the AdaptiqAI design), scripts/remote-spec.mjs (the Remote namespace; scripts/gen-typert.mjs turns it into the Typert artifacts the harness loads).

The UI uses PP Frama when it is installed on the computer. The package does not ship PP Frama (its licence does not allow it); otherwise it falls back to Manrope, an SIL Open Font License grotesk embedded in the browser bundle (licence in assets/fonts/Manrope-OFL.txt).