Updated 2026-10-31 · West Mao
How to use a personal agent on DeepSeek's open-source foundation
You close the laptop and the work continues. That is the promise a personal agent makes: hand it a standing assignment, and it wakes on a schedule or an event, takes the next step, and asks only when the decision belongs to you. Our personal agents overview covered what these products can and cannot do. The follow-up question, for anyone who runs DeepSeek, is what sits underneath them. In October 2026 that question got a concrete answer, because DeepSeek published the load-bearing parts of its own stack. This guide connects the pieces, then shows how to run a personal agent on them.
What did DeepSeek actually open-source?
Three releases, each at a different layer of the stack.
The model side. DeepSeek-V4.1 supports deferred tool loading in the Messages format and client-executed tool search in the Responses format, two features aimed at agents that carry large tool catalogs. The architecture also stores less state than a conventional transformer: cross-layer KV reuse, and bounded replay on the decoder side, which DeepSeek's deployment Q&A credits with nearly halving total prefill compute in production.
The engine. DeepInfer, published October 20, 2026, is the inference engine DeepSeek serves its own models with. The public release is deliberately narrow: offline inference for one model, DeepSeek-V4.1-Flash, on two hardware paths, NVIDIA SM100 through CUDA and NCCL, and Huawei Ascend 950 through CANN and HCCL. The repository credits vLLM as its main starting point and adds a C++ engine for scheduling and input preparation.
The API layer. deepseek-recipe is a collection of Rust libraries with Python bindings. It converts requests in the Messages, Chat Completions, and Responses formats into one internal Conversation format, renders DeepSeek V4 or V4.1 prompts, encodes them to token IDs with an attached tokenizer, and parses model output back into responses in the format the caller asked for. Its README states the boundary plainly: the caller provides model inference, tool execution, and HTTP transport.
Model facts, an engine, and the glue between API formats. The word missing from that list is "agent", and that gap is the subject of the next two sections.
Why is agent traffic different from chat traffic?
A chat session is one long conversation. An agent session is many short ones: wake up, load task state, make a few tool calls, write a progress note, sleep. You can see this profile in the details DeepSeek published about production, and in how fast the open-source ecosystem reacted to it.
Production keeps KV cache blocks for 3 days for agent traffic, against 7 days for chatbot traffic, in 3FS storage with 10+2 erasure coding. Agent context gets re-read at every wake, so the cache retention window is a first-class decision, not a leftover setting.
One week after the DeepInfer release, vLLM shipped DeepInfer-derived changes including dedicated support for DSpark draft generation in "the small-batch decode pattern that agents generate", and cited SemiAnalysis's AgentX test for its rack-scale throughput figure of 954K tokens per second per GPU.
Bounded replay, the architectural trick behind the prefill savings, pays off exactly when every wake begins by re-reading what the agent already did. Agent workloads are the design center now, not an afterthought. That is the quiet argument of the whole release: the cheapest personal agent to run is one whose engine expects this traffic shape.
What does the foundation not include?
Everything that makes an agent personal. Our personal agents overview breaks the missing layer into four pieces: a working environment that keeps files and state, connected apps, an identity and access model, and a control surface for tasks, approvals, memory, and revocation. DeepInfer's own release notes draw the same line on the serving side: global KV cache management, prefill-decode disaggregation, and cross-cluster load balancing stayed home.
The closed products make the same trade in the opposite direction. Meta's Muse, launched September 8, 2026, ships the loop, the cloud computer, and the controls, but on Meta's model. Grok Bot ships the loop too, with one caveat: every Bot on one account shares one persistent computer, files and logins included, so separate Bots are not separate security zones. The open stack gives you the bottom layers on your own terms. The loop is your job.
| Layer | What DeepSeek shipped open source | What you still add |
|---|---|---|
| Model | V4.1 tool features (deferred tool loading, tool search), KV reuse, bounded replay | Your prompts, tool definitions, memory policy |
| Engine | DeepInfer: offline inference for V4.1-Flash on SM100 and Ascend 950 | A serving stack if you go online: cache storage, disaggregation, load balancing |
| API | deepseek-recipe: Messages / Chat Completions / Responses conversion, prompt rendering, tokenizer | HTTP transport, tool execution, an inference backend |
| Agent | Nothing | The whole loop: standing tasks, wake triggers, approvals, identity |
Which route fits: API, self-hosted engine, or your own build?
Route A, the DeepSeek API plus an agent application. Run an agent runtime that speaks to the hosted DeepSeek API. This is the fastest start and the route most personal-agent users actually take. Our DeepSeek Harness setup guide walks through one such runtime, and the dsh-context plugin guide shows how to give it project-aware context. You provide a key or a plan; the provider worries about serving.
Route B, a self-hosted engine. Run DeepInfer yourself for offline inference, or run vLLM or SGLang, which absorbed the DeepInfer optimizations within a week of the release. On matched configurations the gap is now single digits: vLLM reports a 6% decode-throughput gap on GB200 at 131K context, and SGLang reports a faster decode step at high concurrency, 28.88 ms against DeepInfer's 31.19 ms at 256 requests per GPU. Note the hardware floor: SM100-class NVIDIA GPUs or Ascend 950. This is not a laptop project. Our DeepInfer setup, hardware requirements, and vLLM/SGLang deployment guides cover this route in depth.
Route C, your own loop on deepseek-recipe. If you want the agent itself to be yours, deepseek-recipe handles the format plumbing and leaves the interesting parts to you. Python 3.10 or newer installs it with python3 -m pip install deepseek-recipe, and converting a Chat Completions request into a V4.1 prompt takes four lines:
What surrounds those four lines is your personal agent: the task store, the scheduler or event listener that wakes it, the tool execution the library explicitly does not provide, and the approval checks. The library also handles the details that bite people later, such as thinking-mode max_tokens defaults (8192 outside thinking mode, 65536 in thinking mode, 131072 at max effort) and the fact that V4 requests with images come back with each image replaced by [Unsupported Image], since only V4.1 accepts them.
A personal agent runs when you are not watching, and unattended sessions spend tokens steadily. DeepSeek Coding Plans pair an official key with direct API connection at a discount, in one-off and explicitly selected recurring options, while stock lasts.
| Route | What you run | You provide | Fits when |
|---|---|---|---|
| A: API + agent app | An agent runtime such as DeepSeek Harness against the hosted API | An API key or Coding Plan | You want a working agent this week |
| B: self-hosted engine | DeepInfer, vLLM, or SGLang on your own GPUs | SM100 or Ascend 950 class hardware, plus a serving layer | Data control or research matters more than setup time |
| C: build on deepseek-recipe | Your own agent service with the library underneath | Inference, tools, transport, and the whole loop | The agent is the product |
from deepseek_recipe import ChatCompletionRequest, ConversionOptions, DeepseekV41Encoding
request = ChatCompletionRequest({
"model": "DeepSeek-V4.1-Flash",
"messages": [{"role": "user", "content": "Hello"}],
})
converted = request.convert(ConversionOptions())
rendered = DeepseekV41Encoding().render_conversation(converted.conversation)
print(rendered.prompt)How do you run the agent loop in practice?
Whatever route you choose, the loop has the same shape, and each part is a decision you make once and then live with.
Write the assignment as a standing task with a completion test. "Watch these three sources and summarize changes weekly" is a task. "Be my research assistant" is not. The completion test should point at an external artifact (a file, a report, a sent draft), not a chat reply.
Pick the wake condition. A schedule (every morning at 8) or an event (a webhook, a new mail, a calendar change). This choice is what separates a personal agent from a chatbot with memory.
Give it an environment, and know its boundaries. The runtime needs somewhere to keep files, browser sessions, and partial results. Remember the Grok Bot lesson: one shared computer per account means one security zone, no matter how many agents you run on it.
Route the irreversible actions through approval. Sending, deleting, and paying ask first. Reading and drafting do not. Write this rule into the runtime's configuration instead of trusting the model's judgment each time.
Keep the action log, including failures. "It sent the email" is less useful than "it tried three times, and the first two bounced." The log is also your audit trail when something surprises you.
What should you check before connecting an account?
The same six questions from our personal agents overview apply here, because the open foundation does not answer any of them for you:
What can it reach? Network access, files, connected apps, browser sessions. A saved session lets it act under your account.
Does it have its own identity, or does it act as you? A separate mailbox and number make actions attributable. A shared login makes them ambiguous.
Can you see what it did, including failed attempts?
What happens when you revoke access? Does a task that started at noon stop using cached sessions at 2 p.m.?
Can you pause one task without cancelling the future schedule? Can you undo a step that has not committed?
How does it prove completion? Look for the external artifact, not the message that says "done".
If your route is a hosted product (Route A), these questions go to the vendor's documentation. If you are building on deepseek-recipe (Route C), every one of them is a feature you have not written yet. Budget accordingly.
FAQ
Is DeepInfer a personal agent?
No. DeepInfer is the inference engine: it turns prompts into tokens, offline, on server-class hardware. A personal agent needs persistence, tools, triggers, and permissions, which are layers above the engine.
Can deepseek-recipe run an agent by itself?
No. It converts API requests between formats, renders and tokenizes DeepSeek prompts, and parses output. The README assigns inference, tool execution, and HTTP transport to the caller, and the agent loop sits on top of those.
Which DeepSeek model should a personal agent use?
The V4.1 family, if the agent carries many tools or handles images: deferred tool loading, client-executed tool search, and image input are V4.1 features, and V4 replaces images with [Unsupported Image]. For text-only agents with a small tool set, either family works.
Do I need the 3-day KV cache?
Not personally. That is a production-serving detail from DeepSeek's own deployment. On Route A the provider handles cache retention; on Routes B and C, session continuity across wakes comes from your own task store and progress notes.
How is this different from using Muse or Grok Bot?
Those products ship the complete loop, computer included, on their model and their terms. The open foundation ships the bottom layers, so you keep model choice, data location, and the ability to inspect the harness, at the cost of building or choosing the loop yourself.
The bottom layers are public now: an engine that expects agent traffic, an API layer that speaks every major request format, and a model family built for tool-heavy work. None of it runs your standing task. That part, the loop that wakes, acts, asks, and remembers, is still yours to choose or to build, and the checks above are how you keep it yours.