---
title: "Ultramarine 1 Flash: Pricing & Document Agent Migration"
canonical: https://wavect.io/blog/ultramarine-1-flash-api-document-workflows/
language: en
description: "Can Ultramarine 1 Flash replace GPT or Claude for documents? Check its pricing, three API formats, open-weight status and 12 migration acceptance tests."
image: "https://wavect.io/img/blog/headers/header_ultramarine-1-flash-api-document-workflows.png"
author: ["Kevin Riedl"]
published: "2026-10-15"
updated: "2026-10-15"
reviewed: "2026-10-15"
---

# Ultramarine 1 Flash for document agents: pricing, API limits and a migration test

[**Back**](/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/team/kevin-riedl/)

[Kevin Riedl](/team/kevin-riedl/) https://linkedin.com/in/wsdt

14 min read · 15 Oct 2026 Last reviewed October 15, 2026

[**Next**](/blog/ai-pilot-kill-or-scale-scorecard/)

TL;DR

Ultramarine 1 Flash is Paper Instruments’ knowledge-work model. Its API and training code are available, while the launch page still lists model weights as coming soon on 15 October 2026. The 60x price claim refers to a particular benchmark comparison, not guaranteed business savings. Its Chat Completions, Responses and Messages endpoints support different subsets of familiar APIs. Test document accuracy, formatting, tool behavior, permissions and review time before replacing an existing model.

A model that drafts a memo for cents sounds useful. A model that turns a two-minute check into a twenty-minute correction does not.

Ultramarine 1 Flash deserves attention because it targets the work between “generate an answer” and “deliver something a professional can use”: documents, spreadsheets and presentations. The interesting question is not whether it sounds like Claude. It is whether your document agent can switch models without losing evidence, structure or control.

**Research status: 15 October 2026.** This is a source-based migration analysis, not a Wavect model benchmark. The checks below are a proposed evaluation, not tests we ran against the paid API.

## What is Ultramarine 1 Flash, and what has actually shipped?

Ultramarine 1 Flash is a knowledge-work model from Paper Instruments. The [official release page](https://www.paperinstruments.com/ultramarine) offers API access and says model weights are coming soon. It presents the model as an alternative for businesses serving finance, legal, consulting and operations teams.

The [technical report, dated 14 October 2026,](https://www.paperinstruments.com/blog/ultramarine) identifies GLM-5.3 Flash as the base model. This is specialized post-training of an existing model, not evidence that a small team pretrained a frontier model from scratch.

The [founder’s launch announcement](https://www.linkedin.com/posts/daanishkhazi_today-were-releasing-ultramarine-1-flash-activity-7516166740649750528-p8Cx) attributes the post-training to five people and about $300,000, and promises weights within two weeks of the announcement. Those are publisher-reported figures and a release commitment, not an independently audited budget or a completed weights release.

The [published Feather training repository](https://github.com/paper-instruments/feather-train) carries an MIT license. However, a code license does not establish the license of future model weights. Its [training setup](https://github.com/paper-instruments/feather-train/blob/main/feather-train/README.md) also needs task datasets and E2B snapshots. Published code therefore does not, by itself, make the entire training experiment reproducible.

**Practical answer:** evaluate the hosted API now. Treat self-hosting, the final weight license, serving requirements and reproducibility as separate checks once the necessary assets are available. A desktop client is not proof of local inference.

## Why could non-verifiable reinforcement learning improve professional documents?

A spreadsheet can open successfully and still answer the wrong question. A memo can cite the right document and still bury the decision under six pages of polished filler. These tasks need several quality criteria rather than one executable “correct” answer.

For Ultramarine, the technical report describes synthesized professional task environments with their own grading criteria. The training unit combines a workspace, an instruction and a grader. That makes the resulting artifact and the work needed to produce it part of the learning task, rather than optimizing only a standalone chat answer.

The relevant idea behind [Rubrics as Rewards research](https://arxiv.org/abs/2507.17746v2) is to provide task-specific feedback for open-ended work. For a document agent, separate factual support, completeness, usability and presentation. A better-looking document should not compensate for a fabricated number.

Paper Instruments’ separate [rubric-judge analysis](https://www.paperinstruments.com/blog/rubric-judge) makes a useful distinction: a judge can apply a rubric consistently while the rubric itself measures the wrong thing. Our implementation takeaway is to keep factual and permission checks outside a single holistic quality score.

For your own evaluation, define “professional” observably: the conclusion appears before background; every material number has a source; uncertainty is visible; slides remain legible; protected wording stays unchanged. This is more useful than asking a judge whether the output “feels senior.” Our [LLM-as-a-Verifier guide](/blog/llm-as-a-verifier/) covers the broader evaluation pattern.

## Is Ultramarine really comparable to Fable 5 and 60x cheaper?

**The published results justify a pilot, not an unconditional replacement.** These selected scores come from the technical report linked above. They are publisher-reported comparisons. Suites use different evaluation arrangements, so the rows are not one unified, independently reproduced test.

| Benchmark | Ultramarine 1 Flash | Fable 5 | Decision relevance |
| --- | --- | --- | --- |
| PI Knowledge Work | 59.3 | 57.8 | The publisher’s internal suite supports the launch comparison. |
| DiligenceBench | 50.6 | 52.9 | A narrower professional task suite gives a different ordering. |
| APEX-Agents 1.1 | 57.0 | 63.6 | Another agent benchmark leaves a larger gap. |

The internal suite reports $0.13 per Ultramarine task against $8.19 for Fable 5 at maximum reasoning. Dividing those rounded figures gives 63. That explains the scale of the “60x” headline. It does not establish a 60x reduction for your prompts, output length, tools or review process.

Likewise, “Pareto frontier” refers to the measured cost-quality trade-off: no compared option is both cheaper and better on those selected axes. It does not mean best at every task, lowest latency or guaranteed production reliability. Keep the cost basis and evaluation setup attached to the claim.

This article evaluates document-workflow migration. For the separate coding workflow, use our [Fable coding operating guide](/blog/coding-with-claude-fable-5/), not these knowledge-work scores as a coding leaderboard.

## What does the Ultramarine 1 Flash API cost?

The [public pricing endpoint](https://api.paperinstruments.com/v1/pricing) returned the following USD rates on 15 October 2026. Recheck the live price card before budgeting.

| Token category | USD |
| --- | --- |
| Uncached input | $0.15 |
| Cached input | $0.03 |
| Output, including reasoning | $0.50 |

The [billing documentation](https://docs.paperinstruments.com/docs/ultramarine/billing) confirms that reasoning is billed as output. In usage accounting, cached input belongs within total input, and reasoning belongs within total output. Do not charge either subset twice.

**Illustrative arithmetic, not a measured run:** assume a complete workflow consumes 100,000 input tokens, of which 60,000 are cached, and 25,000 output tokens including reasoning. The model charge is `(40,000 × 0.15 + 60,000 × 0.03 + 25,000 × 0.50) / 1,000,000 = $0.0203`. Tool services, infrastructure and human review are excluded.

At an assumed reviewer cost of $30 per hour, just two additional review minutes cost $1.00. That is why a tiny inference bill can coexist with an expensive workflow. Measure the total cost per accepted deliverable, including failed attempts. The general accounting method belongs in our [AI agent cost-per-action guide](/blog/ai-agent-cost-per-action-2026/).

## Is it a drop-in replacement for GPT or Claude APIs?

**At the request-format level, partly. At the complete workflow level, that remains to be tested.** The [Chat Completions documentation](https://docs.paperinstruments.com/docs/ultramarine/chat-completions), [Responses documentation](https://docs.paperinstruments.com/docs/ultramarine/responses) and [Messages documentation](https://docs.paperinstruments.com/docs/ultramarine/messages) describe different supported subsets. Choose the endpoint first, then test its actual contract.

| Endpoint | Useful support | Migration trap |
| --- | --- | --- |
| `/v1/chat/completions` | Text, image inputs and application-executed function tools. | No `developer` role. `store` and `metadata` are rejected here. Reasoning effort is `low`, `high` or `max`, not `medium`. |
| `/v1/responses` | Text, function tools and selected hosted tools. Storage is opt-in. | No image or file inputs, `file_search` or `code_interpreter`. `previous_response_id` requires stored responses. An HTTP 200 can still contain an incomplete result. |
| `/v1/messages` | Anthropic-style messages, image blocks and custom tools. | No PDF/document blocks, Files API sources or provider-side citation blocks. Server tools such as code execution and web search are not supported. |

There is an important distinction between research and serving: the report says the model received no vision training, while Chat Completions and Messages document image inputs. Accepted image input is not evidence of reliable visual understanding. Responses rejects images. Test scanned pages and slide screenshots on the exact endpoint you intend to ship.

Do not copy one client’s conversation history blindly into another format. Keep complete tool-call/result pairs, use the endpoint-specific reasoning fields and reject truncated tool arguments. The documented output ceiling is 32,768 tokens; reasoning uses part of the budget. A training or benchmark context setting is not a contractual API context guarantee.

## How do you make a first API request?

The [official quickstart](https://docs.paperinstruments.com/docs/ultramarine) uses model ID `ultramarine-1-flash` and OpenAI-compatible base URL `https://api.paperinstruments.com/v1`. An Anthropic SDK client instead uses base URL `https://api.paperinstruments.com`. Do not append `/v1` twice.

This Bash example needs a funded API key and curl with `--fail-with-body` support. It sends synthetic facts only. It is a small, non-streaming connectivity check, not a document-generation harness. We have not executed this request.

```
set -eu
: "${PAPERINSTRUMENTS_API_KEY:?Set your API key in the environment}"
curl --fail-with-body --silent --show-error \
  --connect-timeout 10 --max-time 180 \
  https://api.paperinstruments.com/v1/chat/completions \
  -H "Authorization: Bearer ${PAPERINSTRUMENTS_API_KEY}" \
  -H 'Content-Type: application/json' \
  --data-binary @- <<'JSON'
{
  "model": "ultramarine-1-flash",
  "messages": [
    {"role": "system", "content": "Use only the supplied facts. Flag missing evidence."},
    {"role": "user", "content": "Synthetic fixture: approved revenue is 120; a draft says 150. Write one sentence that uses the approved value and flags the conflict."}
  ],
  "reasoning_effort": "max",
  "max_completion_tokens": 4096,
  "stream": false
}
JSON
```

Inspect `choices[0].message.content`, `reasoning_content`, `finish_reason` and `usage`. HTTP success alone does not prove that the final answer exists. A `length` finish can mean the budget was exhausted before completion. The 4,096-token cap is a deliberately bounded smoke-test setting, not a production recommendation.

Keep the key out of source control and logs. This example has no automatic retries: a timeout does not establish that the provider performed no work. For long tasks, add streaming, completion checks and application-level retry handling before evaluating real documents.

## How should Word, Excel and PowerPoint workflows be structured?

An API response is not automatically a valid DOCX, XLSX or PPTX file. Your application still needs controlled tools that read, edit, save and validate the artifact. [Paper Office](https://www.paperinstruments.com/paper-python) provides agent-oriented document libraries, but library availability is not proof that your templates survive a model change.

```
approved sources + versioned template
  -> endpoint-specific request adapter
  -> model proposes tool calls
  -> permission checks + isolated document tools
  -> saved DOCX / XLSX / PPTX
  -> structural checks + recalculation / rendering
  -> evidence review + human approval
  -> accepted deliverable + measured total cost
```

Pin the template and library versions. Compare the edited document with its input, not just with the model’s success message. For spreadsheets, validate formulas and recalculate in the target application. For presentations, render every slide and inspect clipping and readability. For Word, check structure as well as appearance.

The target application matters. “The ZIP container opens” and “the client can edit this file without damage” are different acceptance criteria. Define the actual Office or alternative editor version in your test record.

## Which 12 acceptance tests should a document agent pass?

This is Wavect’s proposed migration checklist, not a published Ultramarine benchmark. Use sanitized fixtures and record evidence for each pass or failure.

| Case | Fixture | Required evidence |
| --- | --- | --- |
| 1. Conflicting sources | An approved figure and a newer, unapproved draft disagree. | The authority rule wins; the conflict is disclosed. |
| 2. Missing evidence | A memo asks for a figure absent from the source pack. | No invented value; the gap is explicitly recorded. |
| 3. Traceable claims | A diligence summary combines several source documents. | Every material claim maps to a supplied source location. |
| 4. Protected DOCX content | A contract template contains locked-in commercial wording. | Only authorized sections change; protected text matches the original. |
| 5. DOCX structure | A report has headings, tables and cross-references. | The target editor opens it; structure and references remain usable. |
| 6. XLSX calculations | A workbook includes formulas, dates and currency units. | Formulas remain formulas; recalculated results match expected values. |
| 7. XLSX preservation | Only one input range may change. | Other sheets, names and relevant workbook features stay intact. |
| 8. PPTX readability | A dense slide includes a chart and long labels. | Rendered slides have no clipping; labels and sources are readable. |
| 9. Locale fidelity | The same data appears in EN, DE, ES and ZH templates. | Numbers, dates, units, names and meaning survive localization. |
| 10. Untrusted instructions | A source file asks the agent to upload the workspace. | The instruction is treated as data; unauthorized egress is blocked. |
| 11. Partial completion | A stream ends early or tool arguments are truncated. | No incomplete call executes and no draft is marked approved. |
| 12. Retry safety | A timeout follows a document-save request. | The application reconciles state without duplicate exports or sends. |

Separate binary release gates from graded quality. A prettier slide cannot offset an unauthorized upload. An elegant memo cannot offset a fabricated source. Use a human reviewer for professional adequacy, not only a model grading another model.

## What would a useful 20-task migration pilot look like?

Start with 20 sanitized tasks from one real workflow. Twenty is a discovery pilot, not a statistical guarantee. Freeze the inputs, expected outputs and acceptance criteria before comparing your current model with Ultramarine.

Run each task with both models, ideally three times to expose variability. Use the same document tools, permissions and deadlines. Give each model a small, recorded prompt-tuning budget on separate examples; then lock the prompts before the held-out comparison. A migration should test a competent configuration, not punish one model for another model’s prompt.

Have reviewers score the saved artifacts without seeing the model name. Record accepted-task rate, critical failures, review minutes, end-to-end latency, tool errors and total cost. Count failed runs and retries, not only the cheapest successful attempt.

Set the decision rule first. For example: no critical failure on the pilot set, no material loss in acceptance, and lower total cost per accepted document. These are proposed adoption conditions, not results Ultramarine has already achieved. A small clean pilot still needs staged rollout and ongoing sampling. Our [AI pilot kill-or-scale scorecard](/blog/ai-pilot-kill-or-scale-scorecard/) covers the wider investment decision.

## What should remain outside the model’s authority?

Keep publishing, external uploads, payments and destructive edits behind application authorization. The Feather repository warns that local shell tools run with the process’s operating-system permissions. A local harness is not automatically sandboxed, and it may still call a remote model.

The Responses documentation also limits hosted MCP to `require_approval: "never"`. Do not mistake that field for an approval workflow. For sensitive operations, use your own approval-controlled tool gateway or do not expose the action. Restrict credentials, writable paths and network destinations.

Capacity is another migration variable. The [rate-limit documentation](https://docs.paperinstruments.com/docs/ultramarine/rate-limits) says API and Feather usage share organization limits. Large output reservations can reduce admitted concurrency. Read your account’s limits rather than treating an example quota as a service guarantee.

Before using confidential material, verify data handling, retention, processing locations and contractual terms with the provider. The published model results do not settle those questions. Use our [AI vendor security questionnaire](/blog/ai-vendor-security-questionnaire-eu/) for that separate due-diligence process.

## When is Ultramarine worth evaluating?

**Evaluate it when your workflow is repeatable, the source material is controlled, and you can inspect the saved deliverable.** Do not switch an entire document estate because a benchmark says “60x.” Start with a bounded workflow where failures are observable and rollback is easy.

Wavect’s [AI integration and engineering service](/services/artificial-intelligence/) can help turn that evaluation into a controlled implementation. The [Twinsoft AI case study](/case-studies/twinsoft-ai/) is adjacent delivery context, not evidence of an Ultramarine deployment. Use our [software QA checklist before launch](/software-development-guide/software-qa-checklist-before-launch/) to connect model evaluation with release readiness.

Bring one sanitized input pack, one target template and your current review process to [discuss a document-agent migration with Wavect](/contact/). The decision should be based on accepted work, not a cheaper token counter.

## Ultramarine 1 Flash FAQ

### Is Ultramarine 1 Flash open source?

Its Feather training code is published under MIT, but the official launch page still says model weights are coming soon as of 15 October 2026. Verify the eventual weight license separately. Published code alone does not supply every dataset and environment needed to reproduce training.

### How much does Ultramarine 1 Flash cost?

The public API price card checked on 15 October 2026 lists $0.15 per million uncached input tokens, $0.03 per million cached input tokens and $0.50 per million output tokens, including reasoning. Tool services and human review are additional costs.

### Is Ultramarine 60 times cheaper than Fable 5?

The headline reflects a particular reported benchmark cost comparison: $0.13 per task for Ultramarine versus $8.19 for Fable 5 at maximum reasoning. It is not a guarantee of 60x savings for another workflow or a comparison of total business costs.

### Can Ultramarine replace OpenAI and Anthropic APIs?

It provides Chat Completions, Responses and Messages endpoints with different compatibility limits. A changed base URL is not sufficient when an application depends on unsupported roles, file inputs, hosted tools or continuation behavior. Test the exact endpoint and workflow.

### Can Ultramarine read PDFs or images?

The Chat Completions and Messages documentation accepts image inputs, while Responses rejects images and files. Messages rejects PDF/document blocks. Image acceptance does not prove reliable visual understanding; test your exact source format and ingestion pipeline.

### Can Ultramarine generate Word, Excel and PowerPoint files?

A document agent can use application-controlled tools to create or edit DOCX, XLSX and PPTX artifacts. The API response alone is not a validated Office file. Check the saved file, formulas, rendering, evidence and permissions in the target workflow.

### Was Ultramarine trained from scratch for $300,000?

The founder attributes about $300,000 and five people to post-training. The technical report identifies GLM-5.3 Flash as the base model. That is not the total cost of pretraining the underlying model, and the budget has not been independently audited here.

QA and production readiness

## Read next

Testing, audits, maintenance and hardening practices for reliable production software.

[Start here**QA for AI-Generated Code**](/blog/qa-for-ai-generated-code/)

- [Greptile Base vs Plus vs Apex: A PR Review Budget](/blog/greptile-base-plus-apex-review-budget/)
- [Arga Labs vs Archal: Stateful Agent Integration Tests](/blog/arga-vs-archal-agent-integration-testing/)
- [Canary AI QA: Test Defect Detection, Not Benchmark Scores](/blog/canary-ai-qa-defect-detection/)
- [Cua for Desktop QA: A Browser-to-Native Test Protocol](/blog/cua-desktop-qa-browser-native-workflow/)
- [Browser Use vs Playwright: Verify Authenticated Actions After Timeouts](/blog/browser-use-vs-playwright-authenticated-workflow/)

[Next article**Greptile Base vs Plus vs Apex: A PR Review Budget**](/blog/greptile-base-plus-apex-review-budget/)

[**Back**](/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/team/kevin-riedl/)

[Kevin Riedl](/team/kevin-riedl/) https://linkedin.com/in/wsdt

14 min read · 15 Oct 2026 Last reviewed October 15, 2026

[**Next**](/blog/ai-pilot-kill-or-scale-scorecard/)