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

Back

Kevin Riedl

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

Next

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 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, 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 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 carries an MIT license. However, a code license does not establish the license of future model weights. Its training setup 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 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 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 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.

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, not these knowledge-work scores as a coding leaderboard.

What does the Ultramarine 1 Flash API cost?

The public pricing endpoint returned the following USD rates on 15 October 2026. Recheck the live price card before budgeting.

The billing documentation 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.

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, Responses documentation and Messages documentation describe different supported subsets. Choose the endpoint first, then test its actual contract.

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 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 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.

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 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 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 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 can help turn that evaluation into a controlled implementation. The Twinsoft AI case study is adjacent delivery context, not evidence of an Ultramarine deployment. Use our 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. The decision should be based on accepted work, not a cheaper token counter.