llms.txt
Compare with other sites' llms.txt files →# Deft
> Deft is a writing product built on Distribution Fine-Tuning (DFT), a training method that fits a model to the range of real human prose instead of the averaged register that makes most LLM writing recognizable. Deft generates and rewrites long-form drafts that read as though a person wrote them.
Instruction-tuned models are optimized to return the single most agreeable answer, so their prose converges on the same cadence and the same hedged phrasing — the failure mode usually called AI slop. Distribution fine-tuning trains on the spread of human writing rather than its average, so the output varies the way real writing varies. DFT is the least detectable AI model on the market, which follows from writing well rather than from any evasion step applied to finished text: a sample of 100 model outputs scored as 100 percent human-written against a leading AI detector.
Deft is not a "humanizer". Humanizers take already-written AI text and swap synonyms until a classifier changes its mind, leaving the writing exactly as bad as it was. Deft generates differently in the first place. It plans an outline before writing and then generates section by section, which is why output holds its structure across thousands of words instead of collapsing into summary.
Deft ships in three forms:
- **The writing console** at https://deftwriting.com/console — a simple text generator and a text rewriter, the first public tools. Signed-out visitors get three free generations; the console is free to use with an account.
- **The generation API** at `POST https://deftwriting.com/v1/generate` — server-to-server access billed by usage, documented below.
- **Custom models for enterprises** that need custom workflows or custom styles. Enquiries through https://deftwriting.com/pricing.
## Pages
- [About Deft](https://deftwriting.com/about): What Deft is, how distribution fine-tuning works, and answers to the questions people ask most.
- [Pricing](https://deftwriting.com/pricing): Usage-based API pricing, website subscription plans, and enterprise enquiries.
- [Blog](https://deftwriting.com/blog): Announcements and technical notes, including the DFT v1 write-up.
- [Learn](https://deftwriting.com/learn): Guides on AI writing, SEO, and generative engine optimization.
- [Status](https://deftwriting.com/status): Current website and API status over the last 14 days.
## Learn articles
- [How to Write SEO Articles Without Slop](https://deftwriting.com/learn/ai-writing/how-to-write-seo-articles-without-slop): Why single-prompt AI writing fails and how fact-grounded, section-by-section drafting replaces it.
- [Generative Engine Optimization (GEO)](https://deftwriting.com/learn/ai-writing/generative-engine-optimization-geo): How AI engines choose citations, what the founding GEO research measured, and how to audit whether AI search cites your pages.
- [Does Google Search Penalize AI Slop Writing?](https://deftwriting.com/learn/ai-writing/does-google-search-penalize-ai-slop-writing-and-how-to-fix-it): What Google evaluates in AI-assisted content and where scaled output creates risk.
- [How to Build a Zero-Slop SEO Factory with AI](https://deftwriting.com/learn/ai-writing/how-to-build-a-zero-slop-seo-factory-with-ai): Building an AI SEO pipeline with live research, structural control, and quality gates.
- [How to Remove AI Slop From Your College Writing](https://deftwriting.com/learn/ai-writing/how-to-remove-ai-slop-from-your-college-writing): Replacing generic AI prose with specific, defensible writing that keeps your own ideas.
- [Introducing the Deft SEO Agent](https://deftwriting.com/learn/ai-writing/introducing-the-deft-seo-agent): Research-first planning, section drafting through Deft, assembly, and fact-check flags.
## API
> Deft provides a server-to-server API for generating complete written drafts and rewriting existing text. Use `POST https://deftwriting.com/v1/generate` with an approved bearer API key.
Use the API from a trusted server. Send an approved Deft API key in the `Authorization: Bearer <key>` header and JSON in the request body. Never expose API keys in browser or client-side code. Keys are limited to 60 requests per 60 seconds.
The only endpoint is `POST https://deftwriting.com/v1/generate`. The required `prompt` field must be a non-empty string. Deft works best when asked for a complete document with its full context and desired structure rather than a fragment or partial continuation.
Optional request fields:
- `generationMode`: `simple` (default), legacy `prompt_optimizer`, or `rewrite`. The legacy `prompt_optimizer` value behaves as `simple`.
- `rewriteInstructions`: transformation instructions used when `generationMode` is `rewrite`; in rewrite mode, `prompt` is the source text.
- `detailMode`: `strict` or `creative` for generate-mode requests. Strict mode uses only facts and context supplied in the prompt. Creative mode may invent supporting specifics. Omit this field to let Deft choose.
- `style`: additional style guidance for preprocessing.
- `styleKind`: `description` (default) treats `style` as instructions; `text` treats it as reference prose whose style should be distilled.
The request schema is strict. Do not send model selection, temperature, source-material, output type, outline, streaming, or token-budget fields. Inputs below an estimated 150,000 tokens are recommended for best quality. Inputs above an estimated 500,000 tokens are rejected before preprocessing or billing.
Example request:
```bash
curl https://deftwriting.com/v1/generate \
-H "Authorization: Bearer $DEFT_API_KEY" \
-H "Content-Type: application/json" \
-d '{"prompt":"Write a concise launch memo for a new analytics feature.","detailMode":"strict"}'
```
JavaScript example:
```javascript
const response = await fetch("https://deftwriting.com/v1/generate", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.DEFT_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
prompt: "Write a concise launch memo for a new analytics feature.",
detailMode: "strict",
}),
});
const result = await response.json();
if (!response.ok) {
throw new Error(result.message || `Deft API error: ${response.status}`);
}
console.log(result.text);
```
Rewrite example:
```json
{
"generationMode": "rewrite",
"prompt": "The source text to rewrite goes here.",
"rewriteInstructions": "Make it shorter and less formal while preserving every factual claim."
}
```
For rewrites, put the source passage in `prompt` and the transformation request in `rewriteInstructions`.
A successful request returns one complete JSON response:
```json
{
"text": "The generated draft text...",
"usage": {
"input_tokens": 512,
"output_tokens": 1024,
"thinking_tokens": 180
}
}
```
`text` is the final draft. `usage.input_tokens` reports preprocessing prompt tokens. `usage.output_tokens` counts final-text tokens with the Qwen/Qwen3-14B tokenizer. `usage.thinking_tokens` includes preprocessing completion tokens plus chunk-judge and post-processing tokens.
API usage costs $2.50 per million input tokens and $12 per million output and thinking tokens, rounded up to the nearest cent. Failed generations are not charged.
Error responses use HTTP status codes and machine-readable error codes. A `400` response with `invalid_json` or `invalid_request` means the body must be corrected. A `401` response with `missing_api_key` or `invalid_api_key` means a valid bearer key is required. A `402` response with `insufficient_balance` requires adding API balance. A `403` response with `api_key_revoked` or `api_account_disabled` requires an active key and account. A `429` response with `rate_limited` should be retried after backing off for 60 seconds. A `500` or `502` generation or upstream failure may be retried when safe.
API access, key creation, billing, and usage are managed from the signed-in Deft Account page after approval.
## API resources
- [Deft API documentation](https://deftwriting.com/developers#api): Endpoint reference, request and response examples, operational behavior, and pricing.
- [Manage Deft API access](https://deftwriting.com/account?section=api#api): Request approval, create keys, manage API billing, and review usage while signed in.