Ultramarine 1 Flash: A Knowledge-Work Model Claiming $0.13 per Task

On October 14, Paper Instruments released Ultramarine 1 Flash. Its target is unusual: not coding, but "professional knowledge work" — finance, law, consulting and operations, producing documents, spreadsheets and presentations.

Founder Daanish Khazi put it plainly: "a team of five, about $300k all in, Fable-class performance at 60x cheaper." The launch post drew over 206K views and attention on Hacker News.

This piece takes the claim apart: where the numbers come from, how it was trained to handle work with no single correct answer, and how much to trust it.

The claim and its evidence

Start with the scorecard. Every figure is Paper Instruments' own.

Read this honestly first. Ultramarine is not first everywhere. DeepSeek V4.1 Flash leads AutomationBench; Gemini 3.8 Flash and Claude Fable 5 lead DiligenceBench and APEX-Agents. On coding benchmarks for reference, the gap is clearer: on Terminal-Bench 2.1, Ultramarine scores 83.2 against DeepSeek V4.1 Flash at 90.6 and Gemini 3.8 Flash at 89.4.

In other words, the strength is not "best in every domain." It is value for money on specific knowledge-work tasks.

The real claim is cost per task

The most eye-catching number in this release is not a score. It is a price.

PI Knowledge Work (Paper Instruments' internal suite, max reasoning)

Ultramarine 1 Flash      59.3 pts   $0.13 per task
Claude Fable 5           57.8 pts   $8.19 per task
GPT-5.6 Sol              55.1 pts   $2.09 per task
Claude Opus 5.5          61.9 pts   $6.96 per task   (2.6 above Ultramarine)
GPT-6 Sol                61.4 pts   $1.26 per task   (2.0 above Ultramarine)

The read matters. Ultramarine beats Fable 5 and GPT-5.6 Sol at a fraction of the cost. It also trails the strongest models — Opus 5.5 and GPT-6 Sol — by about two points. The paper calls this "sitting on the cost-quality frontier," noting that of 39 other runs, 27 cost more and scored lower.

Keep in mind that this table is the vendor's internal benchmark. But putting "cost per task" front and center is genuinely useful. When evaluating agents we usually stare at per-token prices, when the decision value is cost per successful task. The background is in Seeing AI Through Cost per Successful Task.

Why it is hard: grading work with no right answer

The technical core is "non-verifiable RL." Let's unpack that.

Coding is easy to grade. Tests pass, a regex matches, the build succeeds. That is why agent post-training has concentrated on verifiable tasks, and coding has held the largest share. But most professional work is not verifiable. A diligence memo, a litigation chronology, an investment-committee deck — none have a single right answer. Quality turns on judgment and taste, so the reward has to be shaped per task.

Paper Instruments' approach formalizes each task into three parts.

One RL task = [environment] + [instruction] + [grader]

environment: the workspace the agent inhabits
             (a filesystem plus live systems: CRM, ERP, warehouse, ticketing)
instruction: the work as a professional would receive it
grader:      the rubric and harness that score the deliverable

The hardest part is writing rubric criteria, and there is a very intuitive trap.

A criterion copied too closely from one reference (overfit)
  -> rejects equally valid alternative answers

A vague criterion (vague)
  -> "provides an appropriate recommendation" sounds fine
     but rewards plausible-sounding errors

A good criterion tests one coherent proposition.
  - what was checked, what decision follows, what remains open
  - independent accomplishments are split into separate criteria
    so success on one earns credit even when another is missed

To automate that judgment, environments, instructions and rubrics are synthesized by per-domain pipelines. The scale:

[curriculum scale]
4 domains        : finance, law, consulting, operations
19 practice areas
88 environment types
one task = several dozen independent agent loops + multiple review rounds
nominal configuration space per practice area: about 10^7 to 10^10

Environments are filled with real material — SEC EDGAR filings (10-K, 10-Q, 8-K, proxy statements, S-1s), public web material (press releases, investor presentations), analyst reports, and synthetic documents (contracts, internal reports, emails). Deliverables are practical work products: Excel models, PowerPoint decks, Word and PDF documents.

How it was trained: the Feather harness

The team did not just build a model. It built a harness, called Feather.

[Feather, summarized]

1. Survey existing harnesses
   Claude Code, Codex, Cursor, Kimi Code, OpenAI Agents SDK,
   OpenCode, OpenHands, Qwen Code, Mini SWE Agent, Terminus,
   SWE-agent — comparing tool contracts and execution structure

2. Build a new Python harness on shared conventions
   - file tools: read, edit, write, grep, glob (dedicated tools)
     - edit/write check the content fingerprint recorded on read
     - if the file changed, the modification is rejected and the
       model must reread
   - shell tools: bash, task_list, task_output, task_stop
     - each call starts a fresh shell; no state carries over
   - planning tool: todo_write (work plan survives compaction)

3. A three-sentence system prompt (about 50 tokens)
   Real production harnesses run 1,800 to 4,400.
   During training, instructions stay minimal so exploration is not
   constrained.

The philosophy is clear: avoid overfitting the model to one harness and train a policy that transfers across many. The blog concedes that training on several harnesses at once was not feasible on its budget, so it built one on shared conventions instead.

Small practical details stand out too. Packing 50 files into a single tarball cut an upload test from 52 seconds to 2.2 seconds — a 96% reduction. The sandbox runs on E2B with separate containers for agent execution, MCP services and grading, so nothing the model does can alter its own harness, credentials or grader.

The limits: how far to trust it

Listing only the upside would be unbalanced. Here is where to be careful.

[Reasons for caution]
1. Reliance on internal evals
   - The cost-quality curve leans on PI Knowledge Work, an internal suite
   - JobBench was developed externally (UW, Stanford, CMU, MIT-IBM Watson),
     but Paper Instruments built its training curriculum around
     professional task types
     -> the training domain and the benchmark domain overlap
        (a benchmark-optimization concern)

2. Weights not released
   - The official page said "model weights coming soon" as of October 15
   - The founder said weights follow in two weeks; the license is unset
   - Feather training code is MIT, but not the full data or environments

3. Not a from-scratch model
   - The base is GLM-5.3 Flash, an existing open model
   - A small team did not pretrain a frontier model; it post-trained
     a strong open model for professional work

[What is confirmed]
- API available: $0.15 input / $0.50 output / $0.03 cached input per 1M tokens
- Reasoning always on, with low / high / max effort
- Output ceiling 32,768 tokens, including reasoning
- OpenAI- and Anthropic-compatible endpoints, plus Word/PPT/Excel libraries

That last point may be the real news. Beyond the "five people, $300k" narrative, this is a demonstration that post-training a strong open model on a specific domain can approach the frontier in that domain. Separate from the benchmark-optimization debate, it shows how far open-model fine-tuning can go.

Conclusion: measure by cost per task before adopting

The briefing's action, turned into a protocol:

[A mini protocol for comparing knowledge-work models]

1. Pick 5 recurring deliverables from your work
   (updating a reconciliation, a weekly report, a proposal draft,
    meeting materials)

2. Run the candidate models on the same input and the same output format
   [ ] identical instructions and files
   [ ] identical reasoning effort
   [ ] identical output format (document, table, slides)

3. Score them with one rubric
   [ ] Factual accuracy  (are the numbers right)
   [ ] Analytical soundness (does the conclusion follow the evidence)
   [ ] Completeness      (are all requested items present)
   [ ] Source fidelity   (does it say which file it came from)
   [ ] Format compliance (does it preserve the original structure)

4. Record cost per task and the human fix-up time together

One line captures it.

Model competition is moving from "reasoning score"
to "quality of the work product divided by cost per task."

Ultramarine 1 Flash aims at exactly that. The claim's weight will be settled when the weights actually land and independent teams reproduce it on the same tasks. Until then, read the numbers as direction and judge by the cost per task of your own work. To go deeper, see Open-Weight Model Cost and Performance and Benchmark Reward Hacking.

Further reading

• Seeing AI Through Cost per Successful Task
• GLM-5.3: Serving Optimizations for Fast Latency
• AI Benchmark Reward Hacking: The Trap of Raising Scores

References

• Ultramarine 1 Flash: Scaling Non-Verifiable RL (Paper Instruments, Oct 14, 2026)
• Ultramarine 1 Flash product page
• Daanish Khazi's launch post (X, Oct 14, 2026)

Go deeper with a course

Handing documents, tables and presentations to AI is best learned by building one small automation yourself. Cut a repetitive task with Excel and Python, then layer AI on top.

• View the Cursor AI Workflow Automation course ↗