DeepSeek V4.1 Flash (1017 Update): Price, Peak Hours, API, Benchmarks, Vision, Free Access and What Changed

DeepSeek-V4.1-Flash is DeepSeek's fast, low-cost model, released on September 10, 2026 and refreshed as DeepSeek-V4.1-Flash-1017 on October 17, 2026. It is a very large open-weights mixture-of-experts model (a 552-billion-parameter backbone, with only 8 to 16 billion parameters active per token) with a 1-million-token context, native image input, and an MIT license. On the DeepSeek API it is called deepseek-flash and costs, off-peak, $0.15 per million input tokens ($0.003 when the input is a cache hit) and $0.60 per million output tokens; weekday peak hours (01:00 to 04:00 and 06:00 to 10:00 UTC) cost double. The 1017 update kept the price and the API name but scores higher, especially on coding and agent tasks (Terminal-Bench 4.0 from 31.2 to 42.3, ProgramBench from 20.3 to 29.1), and finishes tasks with shorter outputs. It is free to use in DeepSeek's website and app, but running it on a normal PC is not realistic. Below: what changed in 1017, the full price breakdown with worked examples, how to call it in Python and curl, thinking effort, vision, benchmarks against GLM-5.3, Kimi K3 and others, the new Search and Fetch tools, and where it runs.

Jake uses DeepSeek's API to draft replies to the shop's support tickets, and on Monday morning he noticed something odd: the drafts were shorter, the bill for the weekend was lower, and he had not changed a single line of code. Ethan checked. Nothing was broken. On October 17, DeepSeek had swapped a new version of the model in behind the same name. It was the kind of upgrade most people would only notice if someone told them, so here is everything worth knowing about it.

Want to run open models on your own machine instead? The cards below cover running DeepSeek locally, other low-cost models, and the local runners to choose from.

What DeepSeek V4.1 Flash is

DeepSeek, the Chinese AI lab behind the R1 and V3 models, sells two tiers through its API: a larger "Pro" line and the cheaper, faster "Flash" line. V4.1 Flash replaced V4 Flash on September 10, 2026, and it is a much bigger model than its name suggests:

• Size: a mixture-of-experts design with a 552-billion-parameter backbone, plus separate memory modules ("Engram") of about 196 billion parameters that are only consulted occasionally. The full checkpoint is about 510 GB.
• Active parameters: only about 8 billion are used per token while reading your input and about 16 billion while writing the answer. That is why it can be both huge and cheap to run at scale.
• Architecture: 40 layers split into a 20-layer encoder and a 20-layer decoder, with a new sparse attention scheme and a compressed cache that needs roughly a quarter of the memory per token of V4 Flash.
• Context: 1 million tokens, enough for a large codebase or several books in one request.
• Input: text and images (natively multimodal); output is text.
• License: open weights under MIT, which allows commercial use.

For comparison, V4 Flash had a 284-billion-parameter backbone with 13 billion active. So V4.1 Flash is roughly twice as large in total, yet uses fewer active parameters per token. "Flash" describes its price and speed on DeepSeek's servers, not its size on your computer; our guide to running V4.1 Flash locally explains what that size means for a PC.

Jake: "Wait, 552 billion is the 'Flash' one?"

Ethan: "Flash means fast and cheap to call, not small. Only a sliver of it works on each word, which is where the speed comes from."

Who V4.1 Flash suits, and who should pick something else

A cheap, capable model is not automatically the right one. A quick guide:

• Good fit: high-volume drafting (support replies, product descriptions, summaries), classification and tagging, coding assistants and agents on non-confidential code, reading screenshots and charts, and any batch job that can run off-peak.
• Good fit with care: customer-facing chat, where you should test tone and accuracy on your own conversations first, and keep a human or a fallback for sensitive questions.
• Pick something else when data must stay in a particular country or inside your own cloud account (use a model you can host there, or a managed service in your Region), when you need the very best result on the hardest reasoning or coding problems (a frontier model still leads there), or when you need image generation, which this model does not do.
• For offline use on a normal PC, a much smaller open model is the realistic option; this one is far too large.

Many teams end up using two models: a cheap one like this for the bulk of routine requests, and a stronger, pricier one for the few that need it, chosen by a simple rule in code (task type, length, or whether the first attempt passed a check).

What changed in DeepSeek-V4.1-Flash-1017

On October 17, 2026, DeepSeek released an updated checkpoint, DeepSeek-V4.1-Flash-1017, and switched its website, app and API to it the same day. It is the same size and architecture; the changes are in training:

• Better results, especially for coding and agents. DeepSeek trained it further with reinforcement learning using self-feedback on complete projects, from games to 3D scenes. The biggest gains are on agent and software tasks.
• Faster task completion and shorter outputs. It reaches answers with fewer tokens, which lowers your bill at the same per-token price. This is what Jake noticed.
• Same price, same name. deepseek-flash now points at 1017. The retired names deepseek-v4-flash and deepseek-v4-flash-vision-exp still work, are routed to 1017, and are billed at the Flash price.
• Tuned for coding agents. It is optimized for DeepSeek Harness (version 0.2.1-rc.1 or later is recommended) and Tencent's CodeBuddy and WorkBuddy.
• Open weights again. The 1017 checkpoint is on Hugging Face and ModelScope under the same MIT license.

Here is how 1017 compares with the September release on DeepSeek's own benchmarks:

Every row went up, and the agent and coding rows went up the most: a jump of 11 points on Terminal-Bench 4.0 is large for a refresh that kept the same size.

DeepSeek V4.1 Flash price: every rate, peak and off-peak

DeepSeek charges per million tokens, with three rates: input that hits the cache (a repeated prefix DeepSeek has seen recently), input that misses the cache, and output. Prices double during weekday peak hours:

Peak hours in other time zones: 01:00 to 04:00 and 06:00 to 10:00 UTC is 9 pm to midnight and 2 am to 6 am in New York (EDT), 2 am to 5 am and 7 am to 11 am in London (BST), and 6:30 am to 9:30 am and 11:30 am to 3:30 pm in India. Everything else, including weekends, is off-peak. If you run batch jobs, scheduling them outside those windows halves the cost.

Worked examples (off-peak):

• A chatbot answer with 3,000 input tokens (2,000 of them a cached system prompt) and 500 output tokens: 1,000 × $0.15/M + 2,000 × $0.003/M + 500 × $0.60/M = $0.00015 + $0.000006 + $0.0003, about $0.00046. A thousand such answers cost about 46 cents.
• A coding agent session reading 2 million tokens (half from cache) and writing 200,000: $0.15 + $0.003 + $0.12 = about $0.27 off-peak, $0.55 at peak.
• Summarizing a 600,000-token document once into 5,000 tokens: $0.09 + $0.003 = about $0.093.

The cache matters more than it looks: cached input costs 2% of uncached input. Keep long, fixed instructions at the start of your prompt and identical between calls, so repeated requests hit the cache. The same idea, with different prices, applies on other platforms; our guide to prompt caching on Amazon Bedrock shows the pattern.

Through OpenRouter, 1017 is listed as deepseek/deepseek-v4.1-flash-1017 at $0.15 input and $0.60 output per million tokens, and the September version remains available as deepseek/deepseek-v4.1-flash-20260910. Other resellers price it differently, some at the peak rate all day, so compare before you commit.

Jake: "So the cheapest thing I can do is run the big jobs at the weekend and keep my instructions the same?"

Ethan: "Those two habits cut most of the bill. The shorter answers from 1017 did the rest for free."

Five steps to a smaller DeepSeek bill:

1. Put fixed text first. System prompts, instructions and reference documents that repeat between calls go at the start of the prompt, unchanged, so they are billed at the cache-hit rate.
2. Move batch work off-peak. Anything that can wait (nightly summaries, bulk classification, report drafts) runs outside the weekday peak windows at half price.
3. Match thinking effort to the task. Leave thinking off for simple drafting and use high or max only where accuracy needs it, because reasoning tokens are billed as output.
4. Cap the output. Set max_tokens to what the task actually needs, so a runaway answer cannot cost you more than you planned.
5. Read the usage numbers. Each response reports prompt, cached and completion tokens; log them for a week and you will see where the money goes.

How to use DeepSeek V4.1 Flash through the API

1. Create an account on DeepSeek's developer platform, add credit, and create an API key.
2. Store the key in an environment variable, for example DEEPSEEK_API_KEY, rather than in your code.
3. Point any OpenAI-compatible client at https://api.deepseek.com with the model name deepseek-flash. An Anthropic-compatible endpoint is also offered at https://api.deepseek.com/anthropic.
4. Turn on thinking and choose a reasoning effort when the task needs it.

Python, with the OpenAI SDK (pip install openai):

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["DEEPSEEK_API_KEY"],
                base_url="https://api.deepseek.com")

resp = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {"role": "system", "content": "You draft short, polite replies to IT support tickets."},
        {"role": "user", "content": "Customer: my printer shows 'spooler error' since the update."},
    ],
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}},
)
for choice in resp.choices:
    print(choice.message.content)
print(resp.usage)   # prompt, cached and completion token counts for your bill

curl:

curl https://api.deepseek.com/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-flash",
    "messages": [{"role": "user", "content": "Explain what a mixture-of-experts model is in two sentences."}],
    "thinking": {"type": "enabled"},
    "reasoning_effort": "high"
  }'

Thinking effort. The public presets are low, high and max. Higher effort means more reasoning tokens before the answer, and you pay for them as output: at the top setting, a task can use around two and a half times the output tokens of the lowest. For everyday questions and drafting, leave thinking off or use low; for coding, math and multi-step agent work, use high; keep max for the hardest problems.

Tools and agents. The model supports function calling through the usual tools parameter, which is how coding agents drive it. If you use a coding agent that lets you pick models, such as OpenCode, you can point it at DeepSeek's endpoint with the same key.

Switching an existing app from another API

Because the API speaks the OpenAI format, moving an existing app to DeepSeek is mostly configuration. A careful switch, step by step:

1. Change two settings: the base URL to https://api.deepseek.com and the model name to deepseek-flash, plus the new API key. Keep them in configuration, not code, so you can switch back in seconds.
2. Run your own test set: 30 to 50 real requests from your app, with the answers you consider good. Compare the new answers side by side; benchmarks tell you little about your particular prompts.
3. Check the extras you rely on: function calling, JSON output, streaming and image input all exist, but the exact behavior of each provider differs slightly, so test every feature your app uses, not just plain chat.
4. Watch the token counts: different models split text into tokens differently, and 1017 writes shorter answers, so compare the cost per task, not the price per token.
5. Roll out gradually: send a slice of traffic first, keep the old provider as a fallback in your code, and widen the slice as results hold up.

Apps built on the Anthropic message format can use DeepSeek's Anthropic-compatible endpoint in the same way. Whichever format you use, keep the provider behind one small function in your code; it makes the next switch, or a fallback during an outage, a one-line change.

Streaming, JSON output and function calling

• Streaming: pass stream=True and read the chunks as they arrive, exactly as with other OpenAI-compatible APIs. For chat interfaces this makes the first words appear almost at once, even when the full answer takes several seconds.
• JSON output: ask for response_format={"type": "json_object"} and say in the prompt what fields you want; validate the result in code before using it, as with any model.
• Function calling: describe your functions in the tools parameter; the model replies with the function name and arguments, your code runs it, and you send the result back. This loop is how coding agents and support bots let the model look things up or take actions.
• Thinking with tools: agents that combine thinking and tool calls tend to use more output tokens per task, so set max_tokens and watch the usage numbers when you first turn them on.

Jake: "My ticket tool asks for JSON with a category and a draft. Does that still work?"

Ethan: "Same request, new base URL. I'd still check the JSON in code before saving it, as we did before."

What it costs compared with other models

The price is the headline, so here is a like-for-like month: an app that reads 10 million input tokens (none cached, to keep it simple) and writes 2 million output tokens.

• DeepSeek V4.1 Flash, off-peak: 10 × $0.15 + 2 × $0.60 = $2.70 (or $5.40 if it all ran at peak).
• MiniMax M3.1 Flash starts at the same $0.15 input price; our MiniMax guide has its output rate.
• GLM-5.3 at $1.40 input and $4.40 output: 10 × $1.40 + 2 × $4.40 = $22.80.
• Kimi K3 at $3.00 input and $15.00 output: 10 × $3.00 + 2 × $15.00 = $60.00.

Two caveats keep this honest. Frontier models from the large US labs cost more again, and on the hardest tasks they still win, as the benchmark table below shows. And the cheapest model per token is only the cheapest per task if it gets the task right the first time; a model that needs two attempts costs double. Test on your own work, measure cost per finished task, and use the cheap model where it is good enough, which for drafting, classification and routine coding is often.

One name, changing model: pinning versions

Jake's Monday surprise has a lesson in it. On DeepSeek's own API, deepseek-flash always points at the current Flash checkpoint, so the model behind your app can change overnight, as it did on October 17. Usually that is an improvement, but any change can shift tone, length or formatting in ways that matter to your app.

• Keep a small regression set: twenty or thirty real requests with the answers you expect. Run them after any announced update, and weekly if the app is important.
• Pin a version where you need stability: some resellers list dated versions separately (on OpenRouter, the September release remains as deepseek/deepseek-v4.1-flash-20260910 next to the 1017 one), and self-hosting a specific checkpoint pins it completely.
• Read the changelog: provider news pages announce new checkpoints; a short note in your team chat when one lands saves a confused Monday.

The trade-off is simple: the floating name gives you improvements for free, a pinned version gives you predictability, and a regression set lets you have most of both, because you see what a new checkpoint changes before your users do. For a ticket-drafting tool, floating is fine; for a pipeline whose output feeds other systems, pinning plus a planned upgrade is safer.

Keeping the spending under control

At these prices the risk is not a large bill from normal use, but a loop that runs away: an agent stuck retrying, or a batch job sent a million documents by mistake. A few guards cover it:

• Prepaid credit: the developer platform works with a balance you top up, which by itself caps how much can be spent; keep it modest and add to it as you need.
• Cap each request with max_tokens, and cap each job in your own code (a maximum number of calls or tokens per run).
• Log usage per feature: the usage numbers in every response, stored with a feature name, show which part of your app spends the money.
• Separate keys for development and production make it obvious where usage came from, and let you revoke one without stopping the other.

Using it inside coding agents

The 1017 update was tuned for agent work, so coding agents are where many people will meet it. A few habits make agent sessions cheaper and safer:

• Use high thinking effort for agent runs that edit code; the extra reasoning tokens usually pay for themselves in fewer failed attempts.
• Limit the loop: set a maximum number of steps or a token budget per task, so an agent that gets stuck stops instead of spending all night.
• Keep the repository context stable: agents resend a lot of the same files and instructions, which is exactly what the cache discount rewards.
• Review every change: run the tests and read the diff before merging, whatever the benchmark scores say.
• Use the recommended harness version if you run DeepSeek Harness (0.2.1-rc.1 or later), since 1017 was optimized for it.

On the earlier worked example, a two-million-token agent session costs well under a dollar off-peak, which is why teams use models like this for routine refactors, test writing and bug triage, and keep a frontier model for the rare hard problem.

DeepSeek V4.1 Flash benchmarks against other models

DeepSeek compares 1017 with several current models. These are DeepSeek's figures, run with its own settings, so treat them as a guide rather than a verdict:

The pattern: on software fixing and automation, 1017 matches or beats much more expensive models; on the hardest terminal, program-building and expert-knowledge tests, Anthropic's Opus 5 stays ahead. The price gap is what makes the comparison interesting: at $0.15 / $0.60 off-peak, V4.1 Flash costs a small fraction of the frontier models in the table for work where it scores close to them.

Is it good for coding? On these numbers, yes, particularly for agent-style work (reading a repository, editing files, running commands), which is exactly what 1017 was tuned for. For the hardest one-shot tasks, a top frontier model still wins more often.

V4.1 Flash vs GLM-5.3. In these numbers, 1017 is ahead of GLM-5.3 on every coding and agent row. GLM-5.3 has its own advantages, such as availability on Amazon Bedrock (see our GLM 5.3 on Bedrock guide) and a local-install path covered in our GLM guide. If price is the deciding factor, our MiniMax M3.1 Flash guide covers another model at the same $0.15 input price.

Getting better answers from Flash

Cheap models reward clear instructions even more than expensive ones. Habits that lift the quality of answers:

1. Put the role and rules in the system prompt, and keep it the same between calls; it is also what makes the cache work.
2. Show one or two examples of the output you want. For the shop's ticket drafts, two good past replies in the prompt did more than a paragraph of instructions.
3. Ask for a format: bullet points, a word limit, or JSON with named fields. Shorter, structured answers are also cheaper.
4. Turn thinking on only where it helps: multi-step problems, code changes and calculations; leave it off for drafting and classification, where it mostly adds cost.
5. Check the answer in code where you can: a JSON parse, a word count, a test suite. A failed check can trigger one retry or a hand-off to a stronger model.

Using the 1-million-token context well

A million tokens is roughly 750,000 words, enough for a large codebase or a stack of manuals in one request. It is powerful and easy to overuse:

• Cost per call: a full million-token prompt costs $0.15 off-peak when uncached, and a few tenths of a cent when it hits the cache, so sending the same large document repeatedly is cheap only if the prefix is identical each time.
• Speed: long prompts take longer to read before the first word of the answer appears, so for interactive use, send only what the question needs.
• Retrieval is often better: for a large set of documents that changes over time, searching for the relevant passages and sending only those (retrieval-augmented generation) is faster, cheaper and easier to keep current than pasting everything in.
• Put the question last: with a long document in the prompt, state the task clearly after the document, so it is the last thing the model reads before answering.

Does DeepSeek V4.1 Flash have vision?

Yes. V4.1 Flash is natively multimodal: it accepts images alongside text and answers in text. When it launched, DeepSeek retired its separate experimental vision model name, deepseek-v4-flash-vision-exp, and routed it to the Flash model, so image understanding now lives in the main model rather than a side variant. On DeepSeek's figures, 1017 scores 92.5 on BabyVision and 83.0 on Chartography with tools, both up from the September release.

It does not generate images. For reading screenshots, charts, scanned forms and photos of error messages, it is a capable and very cheap option; for creating images you need a separate image model.

The community GGUF builds of 1017 for local use are text only for now, so if you run it yourself through llama.cpp, image input is not available yet.

Is DeepSeek V4.1 Flash free?

• DeepSeek's website and app: free to use for chat, and they run 1017.
• The API: paid, per token, as above. At these prices, light personal use often costs cents per month.
• HuggingChat: the model page lists HuggingChat as a way to try it in the browser.
• The weights: free to download under MIT, but you need server-class hardware to run them.
• Is it open source? Open weights under a permissive license, which is what most people mean; the training data and full training code are not published.

Privacy is the usual trade-off with any free hosted chat: what you type is processed on DeepSeek's servers. For sensitive data, either use the API under its terms with care, or run a smaller model fully offline on your own machine.

Jake: "So I could have just used the app instead of the API?"

Ethan: "For typing questions yourself, yes. The API is for when your own program sends the questions, like your ticket drafts."

Data, privacy and using it at work

Before you send company data to any hosted model, read its terms and decide what you are comfortable sharing. A few practical points for DeepSeek's API in particular:

• Where it runs: DeepSeek is a Chinese company, and requests to its own API are processed on its infrastructure. Some organizations have rules about where data may be processed; check yours before connecting work systems.
• What to send: generic drafting, coding help on non-confidential code, and public information are low-risk; customer personal data, credentials and confidential documents are not, on any third-party API.
• Other hosts: because the weights are open, other providers also serve the model; OpenRouter, for example, routes to several hosts. If location matters, choose a provider whose data centers and terms fit your rules.
• Full control: self-hosting the weights in your own cloud account keeps everything inside your boundary, at a much higher running cost (see the AWS section below).

The shop's rule is simple and works for most small teams: anything with a customer's name, address or order details never goes to an external API; generic text and code does. A small local model handles the sensitive bits in the back office.

Using it from Windows and everyday tools

Most people first try a model like this from tools they already use on a Windows PC:

• Store the key as a user environment variable, either in System Properties, Environment Variables, or in PowerShell with [Environment]::SetEnvironmentVariable("DEEPSEEK_API_KEY", "sk-...", "User"), then open a new terminal so programs can see it.
• VS Code coding assistants that accept an OpenAI-compatible endpoint (several popular open-source extensions do) can use DeepSeek by setting the base URL, model name and key in their settings.
• Chat desktop apps that let you add a custom OpenAI-compatible provider work the same way, which is a cheap way to have a capable assistant on your desktop.
• Spreadsheet and automation tools that can call a web API can send rows to the model for classification or summarizing, which at these prices costs very little per row.

Treat the API key like a password: if it ends up in a shared file or a screenshot, revoke it in the developer platform and create a new one.

Common API errors and what they mean

• 401 Unauthorized: the key is missing, mistyped or revoked; check the environment variable your program actually reads.
• 402 Insufficient balance: the account has run out of credit; top up in the developer platform. A small automatic top-up or a balance alert avoids surprise stops.
• 400 or 422 errors: the request body has a wrong field or value, often a parameter name copied from another provider's documentation.
• 429 Too many requests: you are sending faster than allowed at that moment; retry with backoff and spread batch work over time.
• 500 and 503 errors, or slow first tokens: the service is busy, which happens more often at peak hours; retry with backoff, and move batch jobs off-peak, which also halves their cost.

Build retries with backoff into any app that depends on the API, and keep a fallback model configured for the moments the service is overloaded.

DeepSeek Search and Fetch APIs

Alongside 1017, DeepSeek opened two web tools to everyone: Search (web search results) and Fetch (retrieving the content of a page), powered by DeepSeek's own search engine. They are what an agent uses to look things up on the live web.

• Price: $0.75 per 1,000 calls, for each of the two endpoints.
• Billing starts: October 31, 2026, at 16:00 UTC. Until then, calls are not billed.
• Free for now for DeepSeek API users when the tools are called as server-side tools from DeepSeek Harness and from the coding agents of Anthropic and OpenAI (Codex).

For a sense of scale: an agent that runs 20 searches and 30 page fetches to research one question makes 50 calls, about 3.75 cents, which can easily cost more than the model tokens for the same task. Watch the call count, not just the token count, once billing starts.

Can you run DeepSeek V4.1 Flash locally?

Not on a normal PC. The full checkpoint is about 510 GB. Community GGUF conversions of 1017 appeared the day it launched, from about 246 GiB (2-bit) to 473 GiB (8-bit), and a 4-bit MLX build of about 432 GB targets 512 GB Macs. As of this writing, the GGUF files do not load in mainline llama.cpp, Ollama or LM Studio: they need an unmerged llama.cpp branch (pull request #28696), built from source, and they are text only. In Ollama, 1017 is offered as a cloud model (deepseek-v4.1-flash:1017-cloud), which runs on Ollama's servers, not yours.

If you have a 256 GB-plus workstation or a 512 GB Mac and want to experiment, our V4.1 Flash local guide keeps the current status and the Mac route. For a normal PC, a smaller model gives you the offline, private experience today; our guide to running DeepSeek models on a Windows PC covers the sizes that fit, and our local runner comparison helps you pick the software.

To put the size in perspective: even the smallest 2-bit build needs more memory than four high-end gaming PCs have between them, and every token still has to read the active experts from that memory, so a machine that barely fits it will also be slow. The model is designed for data-center hardware, where its small number of active parameters makes it fast and cheap per user. For home and office machines, the sensible pattern is the one the shop uses: a smaller open model for private, offline work, and the API for everything else.

For self-hosting on servers, you can serve it with vLLM, SGLang or Docker Model Runner, and DeepSeek invites organizations planning very large deployments (on the order of 2,000 GPUs) to contact it directly.

DeepSeek models on AWS

If your work already runs on AWS, there are two routes to DeepSeek models:

• Amazon Bedrock offers earlier DeepSeek models (such as DeepSeek-R1 and DeepSeek-V3.1) as fully managed, pay-per-token models, with Bedrock's IAM, logging and guardrails. Check the Bedrock model catalog in your Region for newer DeepSeek versions; availability of V4.1 Flash on Bedrock is not something to assume.
• Self-hosting on EC2: the open weights can be served with vLLM or SGLang on GPU instances with enough combined memory for a 510 GB checkpoint, such as 8-GPU H200 or B200 instances. This gives you full control and keeps data in your account, at the cost of running and paying for the hardware around the clock.

For most teams, calling DeepSeek's API (or a managed Bedrock model) is far cheaper than self-hosting a model this size, unless data rules require it to stay in your own account. If you build on Bedrock in Python, our LangChain with Bedrock guide shows how to keep the model choice swappable.

Frequently asked questions

Jake's ticket drafts run on 1017 now, with the long instructions moved to the top of the prompt so they hit the cache, and the overnight batch of follow-up emails scheduled for Saturday. The monthly bill for the whole thing is smaller than the shop's coffee budget for a week. Ethan's only rule: anything with a customer's personal details stays on the local model in the back office, and only the generic drafting goes to the API.

Since the Monday surprise, two things changed in how they run it. A list of thirty past tickets with good replies now runs against the model every Monday morning, so any future checkpoint change shows up in a test before it shows up in a customer's inbox. And the API key, the base URL and the model name live in one settings file, so if DeepSeek is overloaded at peak time or a better-value model appears, switching takes a minute, not an afternoon. Neither change cost anything, and both would have saved the confused Monday morning in the first place.

Revision note. Written October 19, 2026, two days after the 1017 update. Prices and local-tool support for this model are moving quickly; we will add dated updates to this page as they change.