Changelog

What's new in Holeacquisition LLC. Feature releases and platform updates.

Claude Fable 5.1 is on Holeacquisition LLC

Claude Fable 5.1 is live on Holeacquisition LLC.

Anthropic shipped it today alongside Claude Mythos 5.1 — the same underlying model under a different safeguard configuration, available only to vetted professionals through Anthropic's trusted-access program. Fable 5.1 is the generally available half, and you can target claude-fable-5-1 across the Holeacquisition LLC stack now.

The headline is not the base price. That hasn't moved: $10 in, $50 out per million tokens, same as Fable 5. The number that moved is the one most people never look at.

Cache Reads Dropped 75%

Fable 5 read from cache at $1.00 per million tokens — the usual 0.1x of the input rate. Fable 5.1 reads at $0.25 per million. That's 0.025x, and it is where Anthropic's claimed ~25% typical and ~45% agentic cost reduction actually comes from.

The distinction matters because of who benefits. If you send one-shot prompts with no shared prefix, your bill is unchanged. If you run agent loops — a stable system prompt and tool list, a conversation that grows over many turns, the same context re-read on every iteration — the cached portion of your input is most of your input, and it just got four times cheaper.

That is the workload Fable 5.1 is built for, and now the pricing agrees.

Benchmarks

BenchmarkScore
Terminal-Bench 4.055.8% (Fable) / 60.9% (Mythos)
CursorBench 3.2.073.4%
Humanity's Last Exam60.9% (no tools)
Terminal-Bench-Science 0.152.6%

Pricing & Specs

Input Tokens$10.00 / million
Output Tokens$50.00 / million
Cache Reads$0.25 / million
Context Window1,000,000 tokens
Max Output128,000 tokens
ThinkingAdaptive (always on)
Effort Levelslow · medium · high · xhigh · max

The Breaking Changes, Handled

Fable 5.1 is not a drop-in replacement at the API level. Three changes will break code written for earlier Claude models:

Forced tool use is gone. tool_choice of any or tool — "you must call a tool", "you must call this tool" — now returns a 400 instead of a response. Anthropic's guidance is to use auto plus an instruction naming the tool.

Thinking is always on. Sending thinking: {type: "disabled"} or a budget_tokens figure is rejected. Depth is controlled through effort levels instead.

History is append-only. Thinking blocks are bound to the model that produced them, and editing an earlier turn invalidates them. Harnesses that rewrite or compact their own history need to account for this.

If you call Fable 5.1 through Holeacquisition LLC, the first one is already handled: a request that asks to force a tool call is translated to the supported form at the gateway rather than forwarded to a guaranteed rejection. Your existing tool-calling code keeps working.

This is the part of an AI gateway that only shows up on a day like today. A model launch is not just a new ID in a config file — it is a set of API changes that break working code, arriving on someone else's schedule. Absorbing that is infrastructure work, and it is the reason to have infrastructure.

Using Fable 5.1

SDK

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.chat.create({
  model: 'claude-fable-5-1',
  messages: [
    {
      role: 'user',
      content: 'Trace this failure across the three services in the repo and propose a fix.'
    }
  ]
});

REST

Bash
curl https://api.cencori.com/v1/chat/completions \
  -H "Authorization: Bearer $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1",
    "messages": [{"role": "user", "content": "Hello from Fable 5.1"}]
  }'

A Note on Mythos 5.1

claude-mythos-5-1 appears in the Holeacquisition LLC model catalog, but it is not generally callable. Anthropic serves Mythos only to vetted cybersecurity and life-sciences professionals through its trusted-access program, so on Holeacquisition LLC it requires an explicit grant on your API key rather than being open to every project.

If your organization is enrolled with Anthropic and you want it enabled, talk to us.

Where It Fits

Fable 5.1 sits at the top of the Claude lineup, above the Opus tier. Claude Opus 5 ($5/$25 per MTok) remains the right default for most production work, and Claude Sonnet 5 ($3/$15) for high-volume routes where latency and cost dominate. Both are on Holeacquisition LLC and both are unaffected by today's changes.

Reach for Fable 5.1 when the task is genuinely hard and long-running — multi-file refactors, deep research, autonomous agent loops that run for many turns. Those are also exactly the workloads where the new cache rate does the most work, which makes the gap between it and the Opus tier narrower in practice than the per-token rates suggest.

Claude Fable 5 remains available if you need to pin to it.

Claude Fable 5.1 is available now for all Holeacquisition LLC customers. Check your Model Catalog to see it in action.

Claude Opus 5 is on Holeacquisition LLC

Claude Opus 5 is live on Holeacquisition LLC.

Anthropic's new Opus-tier flagship succeeds Claude Opus 4.8 as the recommended default for complex agentic coding and enterprise work — with Anthropic describing it as coming close to the frontier intelligence of Claude Fable 5 at half the price. Opus 4.8 remains fully supported on Holeacquisition LLC if you need to pin to it.

Starting today, you can target claude-opus-5 across our entire unified API Gateway, with all billing trackers and security layers configured automatically.

Introducing Claude Opus 5

Opus 5 is Anthropic's pick for the hardest agentic coding and enterprise workloads — the model to reach for when a task is genuinely complex rather than routine. It supports the same adaptive thinking, vision, tool use, and streaming capabilities as the rest of the current Claude lineup, with a 1,000,000 token context window and up to 128,000 tokens of output per request.

Pricing & Specs

Claude Opus 5 is priced identically to Opus 4.8 — no premium for the upgrade.

MetricValue
Input Price$5.00 / million tokens
Output Price$25.00 / million tokens
Context Window1,000,000 tokens
Max Output128,000 tokens
Model IDclaude-opus-5

Powering Claude Opus 5 with Holeacquisition LLC

Integrating new frontier models is trivial when your applications are built on Holeacquisition LLC's intelligence infrastructure:

  1. Decoupled Billing & Credit Quotas: Holeacquisition LLC manages credit allocations, end-user billing, and budget caps at the proxy level. Switching your workloads to claude-opus-5 doesn't require touching your billing logic — Holeacquisition LLC tracks usage at the configured provider rate, without a gateway markup. Any markup you configure for your own end users is separate.
  2. Enterprise Security Layer: Holeacquisition LLC's input and output security pipeline — PII detection, jailbreak detection, and custom data rules — applies to Opus 5 traffic the same way it does to every other model on the gateway, with full audit logging.
  3. Seamless Model Failovers: Opus 5 is now the default Anthropic fallback target for our GPT-5.5 and o3 traffic on Holeacquisition LLC. If your Claude Opus 5 usage hits provider rate limits, traffic can automatically route to GPT-5.5 or Gemini 3.1 Pro Preview without breaking active client sessions.

Using Claude Opus 5 in Holeacquisition LLC

You can begin targeting the new model immediately using our TypeScript SDK:

TypeScript
import { cencori } from 'cencori';

const response = await cencori.chat.create({
  model: 'claude-opus-5',
  messages: [
    {
      role: 'user',
      content: 'Refactor this service to handle concurrent writes safely.'
    }
  ]
});

Claude Opus 5 is available now for all Holeacquisition LLC customers. Check your Model Catalog to see it in action.

Helix is on Holeacquisition LLC

Helix is on Holeacquisition LLC.

Built by Launchverse, Helix is an autonomous AI cloud engineer — a model that plans, reasons about real infrastructure, and (on its own platform) deploys, troubleshoots, and remediates live applications. Starting today, you can reach its advisor persona through Holeacquisition LLC with zero new setup: pick helix-advisor and the gateway routes to it, with billing, logging, and PII redaction applied like any other model.

What makes Helix different

Most chat models reason about code in the abstract. Helix reasons like an engineer who actually ships — it's the brain of an agent that inspects deployment logs, diagnoses build failures, plans migrations, and verifies health before calling a change done. helix-advisor brings that grounded, operations-aware perspective to a normal chat call:

  • Architecture & design — trade-offs, service boundaries, scaling strategy.
  • Debugging guidance — reason through build failures, runtime errors, and misconfiguration.
  • Deployment planning — migration steps, rollout strategy, what to check before and after.
  • Cost estimates — sizing and spend reasoning for cloud workloads.

helix-advisor is read-only — it advises, it doesn't act on your infrastructure. That makes it a safe, drop-in reasoning model for engineering workflows.

Specs & pricing

Model IDhelix-advisor
ModeAdvisor (read-only)
Context Window128,000 tokens
Pricing$1.50 / 1M input · $6.00 / 1M output
ProviderHelix by Launchverse (via Holeacquisition LLC Gateway)
APIOpenAI-compatible, streaming supported

Using Helix in Holeacquisition LLC

It's OpenAI-compatible — switch the model ID and go.

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.ai.chat({
  model: 'helix-advisor',
  messages: [
    { role: 'user', content: 'My Next.js build fails on Prisma generate in CI. How should I debug it?' }
  ]
});
Bash
curl -X POST https://cencori.com/api/ai/chat \
  -H "CENCORI_API_KEY: $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "helix-advisor",
    "messages": [{"role":"user","content":"Plan a zero-downtime Postgres migration for a Node app."}]
  }'

Or select Helix Advisor directly in the playground and model catalog.

What we shipped in Holeacquisition LLC

  • Helix registered as a native provider in the Holeacquisition LLC model catalog.
  • helix-advisor available across the gateway — SDK, REST, and playground — no custom setup.
  • Holeacquisition LLC's cost tracking, logging, data rules, and observability apply automatically.

What's next

Helix's advisor is the first step. Its autonomous personas — the ones that create sandboxes, apply multi-file changes, deploy, and verify — operate on a project with an autonomy level and human-approval gates. Bringing those to Holeacquisition LLC means mapping that execution context onto Holeacquisition LLC's agent and session surface, which is on the roadmap. For now, helix-advisor gives you Helix's engineering judgment as a clean, billable chat model.

Select helix-advisor from your project dashboard, or see the Models Catalog.

Maximo Atlas Preview Is Live on Holeacquisition LLC

Maximo Atlas Preview is live on Holeacquisition LLC.

Update — August 11, 2026: The preview model has been retired. Use the production model ID maximo-atlas-1.1 for new requests. The examples below have been updated to the production slug.

Built by Maximo AI in Nigeria, Atlas is an Opus-class proprietary coding and agent model available now — completely free during the preview period. It delivers competitive benchmark results across software engineering, browsing, tool use, and reasoning, at a fraction of the cost of comparable frontier models.

The original preview used maximo-atlas-preview; current integrations should target maximo-atlas-1.1 across the Holeacquisition LLC stack.

Why This Matters

Atlas is the first Opus-class model built by an African AI team. It holds its own against frontier alternatives on benchmarks like TerminalBench (75.0%), SWE-bench Pro (61.0%), and BrowseComp (84.0%), while costing dramatically less — $0.20/$1.00 per 1M tokens after preview, and completely free until July 21.

For Holeacquisition LLC users, this means a capable reasoning and coding model with no cost barrier during the preview window, and a strong budget option afterward.

Key Specs

Context Window262,000 tokens
Max Output262,000 tokens
Pricing (Preview)Free
Pricing (Post-Preview)$0.20 / $1.00 per 1M tokens
InputText + Image
OutputText
CapabilitiesReasoning, Tool/Function Calling, JSON Mode, Structured Outputs, Web Search

Using Atlas in Holeacquisition LLC

SDK

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.ai.chat({
  model: 'maximo-atlas-1.1',
  messages: [
    { role: 'system', content: 'You are a senior software engineer.' },
    { role: 'user', content: 'Review this pull request for potential issues.' }
  ]
});

REST API

Bash
curl -X POST https://cencori.com/api/ai/chat \
  -H "CENCORI_API_KEY: $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "maximo-atlas-1.1",
    "messages": [
      {"role": "user", "content": "Write a Python script to analyze server logs."}
    ]
  }'

Benchmark Highlights

BenchmarkAtlas Preview
TerminalBench 2.175.0%
SWE-bench Pro61.0%
BrowseComp84.0%
SWE-bench Multilingual75.3%
FrontierScience-Olympiad74.0%
Claw Eval68.0%
AA-LCR74.0%

What We Shipped in Holeacquisition LLC

  • Maximo AI registered as a native provider in our model catalog
  • maximo-atlas-1.1 available across the Holeacquisition LLC gateway — no custom provider setup needed
  • Full support for streaming, tool calling, structured outputs, and reasoning
  • Holeacquisition LLC's security logging, data rules, and observability apply automatically

Notes for Production Teams

  • The preview is free until July 21, 2026 at 00:00 UTC. After that, pricing is $0.20/1M input tokens and $1.00/1M output tokens.
  • Atlas is an OpenAI-compatible provider. If you already call Holeacquisition LLC chat endpoints, switch the model ID and go.
  • The current API model ID is maximo-atlas-1.1.

References

Spitch is on Holeacquisition LLC

Spitch is live on Holeacquisition LLC.

Every major voice provider wraps English, and a handful do European and Asian languages well. Almost none do native West African voice — Yoruba, Hausa, Igbo — in either direction. Spitch does, and starting today you can reach it through the Holeacquisition LLC Voice API with zero new setup: pick a Spitch model and the gateway routes to it, with billing, PII redaction, and BYOK applied the same way as every other provider.

What Makes Spitch Different

1. Native African languages, both directions

Spitch handles text-to-speech and speech-to-text for Yoruba, Hausa, Igbo, English, and Amharic — not transliteration or a heavy accent on an English model, but models built for these languages. For products serving Nigerian and East African users, this is the piece that was missing from every other voice stack.

2. Built for how people actually communicate

Across much of West Africa, voice notes are the default — not typing. Spitch on Holeacquisition LLC means you can accept a WhatsApp voice note in Yoruba, transcribe it, run it through a model, and reply with a Yoruba voice note — a full loop in a few lines. It's also ideal for IVR, voicemail, and voice-first apps where typing English is a barrier.

3. Ops built in

Because it runs through the gateway, every Spitch call is metered and logged, PII-redacted on the way in, and BYOK-ready per project. Spend caps and cost tracking apply automatically — the same operational layer as chat, vision, and documents.

Pricing & Specs

TTS$0.030 / 1,000 characters
STT$0.010 / minute
LanguagesYoruba, Hausa, Igbo, English, Amharic
ProviderSpitch (via Holeacquisition LLC Gateway)
Model IDsspitch-tts, spitch-stt

Using Spitch in Holeacquisition LLC

The provider is inferred from the model — you never pass a provider name.

TypeScript
// Speak Yoruba
const { audio } = await cencori.voice.speak({
  input: 'Bawo ni, e ku aaro.',
  model: 'spitch-tts',
  voice: 'sade',
  language: 'yo',
});

// Transcribe a Yoruba voice note
const { text } = await cencori.voice.transcribe({
  audio: voiceNote,
  model: 'spitch-stt',
  language: 'yo',
});
Python
# Python
audio = cencori.voice.speak("Sannu, ina kwana?", model="spitch-tts", language="ha")
open("hausa.mp3", "wb").write(audio)

The voice namespace is available across all five SDKs — TypeScript, Python, Go, PHP, and Rust — and the drop-in <VoiceRecorder /> and <SpeakButton /> React components work with Spitch models out of the box.

Why this matters

Localized intelligence isn't just about text. A bank chatbot, a government service line, or a fintech support flow only reaches most Nigerians if it can listen and speak in the language they use. Spitch on Holeacquisition LLC makes that a one-line change — and keeps the billing, security, and observability you already rely on.

Start with the Voice docs, or select spitch-tts / spitch-stt directly from your project dashboard.

GPT-5.6 Sol, Terra & Luna Are Live on Holeacquisition LLC

GPT-5.6 is live on Holeacquisition LLC — the full family: Sol, Terra, and Luna.

OpenAI's latest generation introduces a tiered architecture where the generation number identifies the model family, and Sol, Terra, and Luna are durable capability tiers that can advance independently. The result is frontier intelligence across three price points, giving teams a clearer choice between raw capability, throughput, and cost.

All three models are available now through the Holeacquisition LLC gateway with zero configuration changes — switch the model ID and go.

The Family

ModelModel IDInput / 1MOutput / 1MPositioning
Solgpt-5.6-sol$5.00$30.00Flagship, max + ultra reasoning, multi-agent
Terragpt-5.6-terra$2.50$15.00Balanced, GPT-5.5-class at half the cost
Lunagpt-5.6-luna$1.00$6.00Fast/affordable, 25x cheaper than GPT-5.5 peak

Sol — New State of the Art

Sol is OpenAI's strongest model. Across agentic coding, cybersecurity, science, and knowledge work, it sets new highs while using fewer tokens and less time than competing frontier models.

  • Terminal-Bench 2.1: 91.9% (SOTA)
  • ExploitBench: 73.5% (vs GPT-5.5's 47.9%)
  • BrowseComp: 92.2% (new SOTA)
  • OSWorld 2.0: 62.6% (surpasses Opus 4.8 using 85% fewer output tokens)
  • Agents' Last Exam: 52.7% (+13.1 over Claude Fable 5)

New max reasoning gives Sol more time to explore alternatives. New ultra mode coordinates four parallel sub-agents to trade higher token use for faster time-to-result on demanding tasks.

Terra — GPT-5.5 Performance at Half the Cost

Terra delivers performance competitive with GPT-5.5 across coding, knowledge work, and agentic benchmarks at 50% lower token cost. For teams currently on GPT-5.5, Terra is an immediate cost-savings opportunity with no capability regression.

Luna — 25x Cost Reduction vs GPT-5.5 Peak

Luna outperforms GPT-5.5 at its highest reasoning setting while costing 25x less. It's ideal for high-volume summarization, drafting, classification, and routine agent loops where throughput matters more than peak depth.

Using GPT-5.6 in Holeacquisition LLC

SDK

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.ai.chat({
  model: 'gpt-5.6-sol',
  messages: [
    { role: 'system', content: 'You are a senior security engineer.' },
    { role: 'user', content: 'Audit this codebase for vulnerabilities.' }
  ]
});

REST API

Bash
curl -X POST https://cencori.com/api/ai/chat \
  -H "CENCORI_API_KEY: $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "messages": [
      {"role": "user", "content": "Summarize this quarter's support tickets."}
    ]
  }'

What We Shipped in Holeacquisition LLC

  • All three GPT-5.6 models registered in our model catalog and provider config
  • Full routing support — no API migration required, swap the model ID in existing calls
  • Holeacquisition LLC's security logging, data rules, and observability apply automatically

Notes for Production Teams

  • API model IDs are gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna
  • Sol supports max and ultra reasoning modes via the OpenAI API
  • If you rely on pinned model versions for evals, keep your existing fallback policy
  • Holeacquisition LLC's default OpenAI pricing for non-free models applies as fallback; configure per-model pricing via the dashboard or API for accurate cost tracking

References

Vision on Holeacquisition LLC

Vision is live.

POST /api/ai/vision takes an image and returns analysis — description, OCR, structured classification, or an answer to your own prompt. Routes across OpenAI GPT-4o, Anthropic Claude, and Google Gemini vision-capable models. Same gateway, same key, same billing, same logs as everything else on Holeacquisition LLC.

But the more interesting part isn't the API. Every AI platform ships a vision endpoint. What Holeacquisition LLC also ships — starting today — is the UI.

The API

Four endpoints. Pick the one that matches what you're doing:

TypeScript
import { Cencori } from 'cencori';
const cencori = new Cencori();

// General analyze with your own prompt
const r1 = await cencori.vision.analyze({
  image: { url: 'https://example.com/photo.jpg' },
  prompt: 'What breed is this?',
});

// Preset: rich description
const r2 = await cencori.vision.describe({ image: { url } });

// Preset: extract text (temperature=0)
const r3 = await cencori.vision.ocr({ image: { url } });

// Preset: structured JSON classification
const r4 = await cencori.vision.classify({ image: { url } });

Accepts URL, base64, or multipart file. Supports JPEG, PNG, WEBP, GIF everywhere; HEIC/HEIF on Gemini. Per-provider size limits (5MB Anthropic, 20MB OpenAI and Google) enforced up front with a clear structured error — no more mystery 500s when a photo is one megabyte too big.

Streaming works too. Set stream: true and you get an SSE stream of text deltas ending with a final chunk carrying the token totals and cost.

Full reference at /docs/api/vision.

It works with any model, not just the vision ones

The other quiet-but-important piece: you don't have to know which models support vision. If you send an image through the regular /chat endpoint on Holeacquisition LLC — no matter which model you picked — it just works.

TypeScript
// You picked claude-3-5-haiku. No vision support natively.
// Cencori sees the image, upgrades to claude-3-5-sonnet-latest, routes through Vision.
// The response is a normal chat completion. You get X-Model-Upgraded: true in the headers.
const response = await cencori.ai.chat({
  model: 'claude-3-5-haiku-latest',
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'What is in this image?' },
      { type: 'image_url', image_url: { url: 'https://…' } }
    ]
  }]
});

Every AI platform makes you pick a vision-capable model up front. If you pick the wrong one, you get a 400. On Holeacquisition LLC you don't have to think about it — vision-capable equivalents in the same model family are auto-selected, and the response tells you when a swap happened.

This is the "unified gateway" pitch actually being true. One request shape. Any model. If it can't natively see, we upgrade it. If it can, we pass through.

The component

Vision is the first Holeacquisition LLC feature that ships with an importable React component.

TypeScript
import { VisionUploader } from 'cencori/react';

<VisionUploader
  endpoint="/api/vision/describe"
  task="describe"
  onResult={(r) => saveResult(r)}
/>

Drag-and-drop uploader with a preview thumbnail, client-side format validation (so users see errors instantly, not after a round trip), and — for JPEG/PNG/WEBP — automatic downscaling when a photo exceeds the provider's size limit. It also renders a clear format-support banner and clean error states.

It's meant to be dropped into your product, not just our dashboard. Your customers get the same polished experience your Holeacquisition LLC dashboard would, without you writing the drag-drop logic, the compression, or the error UI.

This is the direction. The next few months of Holeacquisition LLC will fill out cencori/react — a chat window, a voice recorder, an agent inspector, a session viewer. The pitch is simple: most AI infrastructure ships you an API and leaves the UI to you. Holeacquisition LLC ships you both.

Five SDKs, one shape

Every SDK gets the same four methods:

  • TypeScript — cencori.vision.{analyze,describe,ocr,classify,analyzeStream} — cencori@1.3.0
  • Python — cencori.vision.{analyze,describe,ocr,classify} — sync + async
  • Go — client.Vision.{Analyze,Describe,OCR,Classify}
  • PHP — $cencori->vision->{analyze,describe,ocr,classify}
  • Rust — cencori.vision.{analyze,describe,ocr,classify} — sync + async

Each SDK ships with a runnable examples/vision.* file so you can see all four methods end-to-end without hunting through docs.

What it's good for

Some ideas we've seen work well:

  • Receipt scanners — upload a photo, get merchant + line items + total as JSON. Full walkthrough at Build a Receipt Scanner.
  • Content moderation — classify user-uploaded images at the edge before storing them
  • Product cataloging — auto-tag inventory photos with categories, colors, and materials
  • Document workflows — OCR invoices and forms into structured data
  • Accessibility — auto-generate alt text for images at upload time

Every request is billed through your usual Holeacquisition LLC spend caps, logged with full metadata, and shows up in your usage dashboard next to your chat calls.

Pricing

Same as any other Holeacquisition LLC model call: the configured provider cost, with no gateway markup. Costs surface in the response payload (cost.cencoriChargeUsd) so you can meter or display them in your product. No separate Vision billing lane.

Getting started

Bash
npm install cencori
TypeScript
import { Cencori } from 'cencori';
const cencori = new Cencori(); // reads CENCORI_API_KEY

const { analysis } = await cencori.vision.analyze({
  image: { url: 'https://example.com/photo.jpg' },
});

Or use the drop-in component in five lines:

TypeScript
import { VisionUploader } from 'cencori/react';

<VisionUploader endpoint="/api/vision" task="describe" onResult={console.log} />

That's it.

Documents on Holeacquisition LLC

Documents is live on Holeacquisition LLC.

Three endpoints. Point at a PDF or image and get back:

  • /api/ai/documents/extract — the full text
  • /api/ai/documents/summarize — a concise summary
  • /api/ai/documents/query — an answer to your question

Same gateway, same key, same billing, same logs as everything else.

The part that isn't obvious

Most "AI document processing" pipelines burn tokens on things that don't need an LLM. Contracts, invoices, reports, resumes — anything exported from Word, Google Docs, or a generator — already have text embedded in the PDF. You don't need Vision OCR to see it. You just need pdf-parse.

Holeacquisition LLC's Documents endpoint checks first, calls the LLM second:

TypeScript
const { text, method } = await cencori.documents.extract({
  document: { url: 'https://example.com/contract.pdf' },
});

console.log(method); // 'pdf_text' — no tokens billed

Only images (and image-based scanned PDFs, once we ship that path) route through Vision OCR. Everything else is native extraction — instant, deterministic, and free.

This matters at scale. A firm processing 10,000 contracts a month on the "PDF → Vision → tokens" pattern pays every time. On Holeacquisition LLC, if the contracts are text-based (they almost always are), the extract calls cost nothing beyond the base gateway request.

method: "pdf_text" in the response tells you the free path ran. method: "vision_ocr" means Vision was invoked and tokens were counted.

Summarize and Query

Extract is one call. /summarize and /query compose extract with a chat model — do the parse for free, then spend a few cents on the actual reasoning:

TypeScript
const { summary } = await cencori.documents.summarize({
  document: { url: 'https://example.com/quarterly-report.pdf' },
});

const { answer } = await cencori.documents.query({
  document: { url: 'https://example.com/contract.pdf' },
  question: 'What is the termination clause?',
});

/query uses a strict system prompt: if the answer isn't in the document, the model returns "Not found in the document." — no hallucinated legal advice, no invented dates. That's a hard requirement for compliance and legal workflows and it's how the endpoint ships by default.

Where you'd use it

  • Contract Q&A — "What's the termination window? What's the auto-renewal clause? What are the payment terms?"
  • Invoice extraction — vendor, PO number, line items, total. Ship a receipt/invoice scanner in an afternoon.
  • Resume screening — years of experience, tech stack match, education. Cheap enough to run on every applicant.
  • Policy compliance — "Does this vendor contract mention GDPR? SOC 2?"
  • Report summarization — feed a 50-page board deck, get a 300-word summary with the numbers preserved.

Five SDKs, one shape

TypeScript
// TypeScript
await cencori.documents.extract({ document: { url } });

// Python
cencori.documents.extract(document_url=url)

// Go
client.Documents.Extract(ctx, &cencori.DocumentParams{DocumentURL: url})

// PHP
$cencori->documents->extract(['document_url' => $url]);

// Rust
cencori.documents.extract(&DocumentParams::from_url(url))

Same methods, same response shape, same error codes across all five languages. Each SDK ships with a runnable examples/documents.* file.

What's not shipped yet

  • Scanned PDFs. Image-only PDFs (no embedded text) return a clear error pointing you at /api/ai/vision with the multi-image field. Server-side page rasterization is the obvious v2 — it's coming, it's just a bigger infrastructure decision.
  • Structured extraction schemas. You can currently ask "return JSON" via the extract prompt, but a first-class schema field (like documents.extract({ schema: z.object({...}) })) is coming.
  • Batch processing. Send a folder of documents at once. Same story as scanned PDFs — v2.

Getting started

Bash
npm install cencori
TypeScript
import { Cencori } from 'cencori';
const cencori = new Cencori(); // reads CENCORI_API_KEY

const { text, method, pageCount } = await cencori.documents.extract({
  document: { url: 'https://example.com/contract.pdf' },
});

That's it.

Vision on Holeacquisition LLC

Vision is live.

POST /api/ai/vision takes an image and returns analysis — description, OCR, structured classification, or an answer to your own prompt. Routes across OpenAI GPT-4o, Anthropic Claude, and Google Gemini vision-capable models. Same gateway, same key, same billing, same logs as everything else on Holeacquisition LLC.

But the more interesting part isn't the API. Every AI platform ships a vision endpoint. What Holeacquisition LLC also ships — starting today — is the UI.

The API

Four endpoints. Pick the one that matches what you're doing:

TypeScript
import { Cencori } from 'cencori';
const cencori = new Cencori();

// General analyze with your own prompt
const r1 = await cencori.vision.analyze({
  image: { url: 'https://example.com/photo.jpg' },
  prompt: 'What breed is this?',
});

// Preset: rich description
const r2 = await cencori.vision.describe({ image: { url } });

// Preset: extract text (temperature=0)
const r3 = await cencori.vision.ocr({ image: { url } });

// Preset: structured JSON classification
const r4 = await cencori.vision.classify({ image: { url } });

Accepts URL, base64, or multipart file. Supports JPEG, PNG, WEBP, GIF everywhere; HEIC/HEIF on Gemini. Per-provider size limits (5MB Anthropic, 20MB OpenAI and Google) enforced up front with a clear structured error — no more mystery 500s when a photo is one megabyte too big.

Streaming works too. Set stream: true and you get an SSE stream of text deltas ending with a final chunk carrying the token totals and cost.

Full reference at /docs/api/vision.

It works with any model, not just the vision ones

The other quiet-but-important piece: you don't have to know which models support vision. If you send an image through the regular /chat endpoint on Holeacquisition LLC — no matter which model you picked — it just works.

TypeScript
// You picked claude-3-5-haiku. No vision support natively.
// Cencori sees the image, upgrades to claude-3-5-sonnet-latest, routes through Vision.
// The response is a normal chat completion. You get X-Model-Upgraded: true in the headers.
const response = await cencori.ai.chat({
  model: 'claude-3-5-haiku-latest',
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'What is in this image?' },
      { type: 'image_url', image_url: { url: 'https://…' } }
    ]
  }]
});

Every AI platform makes you pick a vision-capable model up front. If you pick the wrong one, you get a 400. On Holeacquisition LLC you don't have to think about it — vision-capable equivalents in the same model family are auto-selected, and the response tells you when a swap happened.

This is the "unified gateway" pitch actually being true. One request shape. Any model. If it can't natively see, we upgrade it. If it can, we pass through.

The component

Vision is the first Holeacquisition LLC feature that ships with an importable React component.

TypeScript
import { VisionUploader } from 'cencori/react';

<VisionUploader
  endpoint="/api/vision/describe"
  task="describe"
  onResult={(r) => saveResult(r)}
/>

Drag-and-drop uploader with a preview thumbnail, client-side format validation (so users see errors instantly, not after a round trip), and — for JPEG/PNG/WEBP — automatic downscaling when a photo exceeds the provider's size limit. It also renders a clear format-support banner and clean error states.

It's meant to be dropped into your product, not just our dashboard. Your customers get the same polished experience your Holeacquisition LLC dashboard would, without you writing the drag-drop logic, the compression, or the error UI.

This is the direction. The next few months of Holeacquisition LLC will fill out cencori/react — a chat window, a voice recorder, an agent inspector, a session viewer. The pitch is simple: most AI infrastructure ships you an API and leaves the UI to you. Holeacquisition LLC ships you both.

Five SDKs, one shape

Every SDK gets the same four methods:

  • TypeScript — cencori.vision.{analyze,describe,ocr,classify,analyzeStream} — cencori@1.3.0
  • Python — cencori.vision.{analyze,describe,ocr,classify} — sync + async
  • Go — client.Vision.{Analyze,Describe,OCR,Classify}
  • PHP — $cencori->vision->{analyze,describe,ocr,classify}
  • Rust — cencori.vision.{analyze,describe,ocr,classify} — sync + async

Each SDK ships with a runnable examples/vision.* file so you can see all four methods end-to-end without hunting through docs.

What it's good for

Some ideas we've seen work well:

  • Receipt scanners — upload a photo, get merchant + line items + total as JSON. Full walkthrough at Build a Receipt Scanner.
  • Content moderation — classify user-uploaded images at the edge before storing them
  • Product cataloging — auto-tag inventory photos with categories, colors, and materials
  • Document workflows — OCR invoices and forms into structured data
  • Accessibility — auto-generate alt text for images at upload time

Every request is billed through your usual Holeacquisition LLC spend caps, logged with full metadata, and shows up in your usage dashboard next to your chat calls.

Pricing

Same as any other Holeacquisition LLC model call: the configured provider cost, with no gateway markup. Costs surface in the response payload (cost.cencoriChargeUsd) so you can meter or display them in your product. No separate Vision billing lane.

Getting started

Bash
npm install cencori
TypeScript
import { Cencori } from 'cencori';
const cencori = new Cencori(); // reads CENCORI_API_KEY

const { analysis } = await cencori.vision.analyze({
  image: { url: 'https://example.com/photo.jpg' },
});

Or use the drop-in component in five lines:

TypeScript
import { VisionUploader } from 'cencori/react';

<VisionUploader endpoint="/api/vision" task="describe" onResult={console.log} />

That's it.

Buy Credits with Crypto

Crypto credit top-ups are live.

You can now add credits to your Holeacquisition LLC account using USDC, USDT, BTC, ETH, SOL, BNB, or TRX — alongside the existing card payments via Bachs.

How It Works

Head to your billing dashboard and toggle from Card to Crypto. Select a credit pack and you'll be redirected to a hosted checkout where you can pay with any supported crypto asset.

Once the transaction confirms on-chain, credits land in your account immediately — no manual approval, no support ticket.

Supported Assets

AssetChains
USDCEthereum, Solana, BNB, TRON
USDTEthereum, Solana, BNB, TRON
BTCBitcoin
ETHEthereum
SOLSolana
BNBBNB
TRXTRON

Why Crypto

Some teams prefer crypto for treasury management. Some operate in regions where card payments are unreliable. Some just want the option.

You don't need to choose one or the other. Both payment methods coexist on the same account. Credits are credits regardless of how you fund them.

Get Started

Visit your organization billing page, switch the toggle to Crypto, and pick a pack.

Claude Sonnet 5 is on Holeacquisition LLC

Claude Sonnet 5 is live on Holeacquisition LLC.

Anthropic just released its most agentic Sonnet model to date. Claude Sonnet 5 narrows the gap between the mid-tier and flagship tiers, delivering capabilities in coding, reasoning, and tool use that are close to those of Claude Opus 4.8, but at a significantly lower price point.

Starting today, you can target claude-sonnet-5 across our entire unified API Gateway, with all billing trackers and security layers configured automatically.

Introducing Claude Sonnet 5

For many builders, the agentic era started with Sonnet-class models. Sonnet 5 represents a strict improvement over Sonnet 4.6, delivering autonomous workflows, terminal utilization, and agentic loop execution that can run reliably in complex environments.

Key Performance Benchmarks

Sonnet 5 sets new standards for mid-tier models across multiple evaluations:

  • Agentic Coding: Scores 63.2% on SWE-bench Pro and 80.4% on Terminal-Bench 2.1, representing substantial leaps over Sonnet 4.6 (58.1% / 67.0%).
  • Computer Use: Achieves 81.2% on OSWorld-Verified (compared to 78.5% for Sonnet 4.6), demonstrating high reliability for autonomous desktop operations.
  • Multidisciplinary Reasoning: Scores 57.4% (with tools) on Humanity's Last Exam, approaching the 57.9% benchmark of Opus 4.8.

Pricing & Specs

Anthropic is offering introductory promotional pricing for API developers through August 31, 2026. Holeacquisition LLC's billing engine automatically handles this promotion in real-time.

MetricPromotional (Through Aug 31, 2026)Standard (After Aug 31, 2026)
Input Price$2.00 / million tokens$3.00 / million tokens
Output Price$10.00 / million tokens$15.00 / million tokens
Context Window1,000,000 tokens1,000,000 tokens
Model IDclaude-sonnet-5claude-sonnet-5

Powering Claude Sonnet 5 with Holeacquisition LLC

Integrating new frontier models is trivial when your applications are built on Holeacquisition LLC's intelligence infrastructure:

  1. Decoupled Billing & Credit Quotas: Holeacquisition LLC manages credit allocations, end-user billing, and budget caps at the proxy level. When you transition your models to claude-sonnet-5, Holeacquisition LLC automatically tracks the introductory rates ($2/$10) and transitions to standard rates on September 1, with zero interruptions to your business model.
  2. Enterprise Security Layer: Sonnet 5 is built for agentic execution. Holeacquisition LLC's enterprise security guardrails shield your system by sanitizing prompt inputs, detecting jailbreak patterns, and logging all activity in compliant audit tables.
  3. Seamless Model Failovers: You can configure failover parameters in the Holeacquisition LLC Dashboard. If your Claude Sonnet 5 usage hits provider rate limits, traffic can automatically route to Claude Opus 4.8 or Gemini 3.5 Pro without breaking active client sessions.

Using Claude Sonnet 5 in Holeacquisition LLC

You can begin targeting the new model immediately using our TypeScript SDK:

TypeScript
import { cencori } from 'cencori';

const response = await cencori.chat.create({
  model: 'claude-sonnet-5',
  messages: [
    {
      role: 'user',
      content: 'Analyze these database schemas and suggest optimization indices.'
    }
  ]
});

Claude Sonnet 5 is available now for all Holeacquisition LLC customers. Check your Model Catalog to see it in action.

Holeacquisition LLC Sessions

Holeacquisition LLC Sessions is live.

Every production agent needs durable execution. Network failures crash conversations. Human-in-the-loop approval flows require polling or webhooks. Cold starts lose context. Every team rebuilds the same plumbing: store messages, manage context windows, handle retries, survive crashes.

Sessions collapses all of that into a single API.

What It Is

Sessions is an event-sourced durable execution layer. Each turn is recorded as an append-only event log. Sessions survive crashes, cold starts, and redeploys. They pause for human approval without consuming compute and resume exactly where they stopped.

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

// Create a session — one call
const session = await cencori.sessions.create();

// Submit a turn — stream SSE events
const stream = await cencori.sessions.submitTurnStream(session.id, {
  input: 'Pull Q3 revenue and email the CFO a summary.',
  tools: [
    { type: 'function', function: { name: 'run_sql', parameters: {...} }, needsApproval: true },
    { type: 'function', function: { name: 'send_email', parameters: {...} }, needsApproval: true },
  ],
  pause_on_tool_calls: true,
});

// Stream handles pause/resume automatically
for await (const event of parseSSE(stream)) {
  if (event.type === 'turn.paused') {
    await notifyHuman(event.data.action_id);
  }
}

That's the whole developer surface. No database setup. No message store. No cron jobs for expiry. No polling for approvals.

The Problem

Building production agents today means stitching together:

  1. A model provider call
  2. A database to store conversation history
  3. Context window management (when to trim, when to summarize)
  4. Retry logic for network failures
  5. Some mechanism for human approval of sensitive tool calls
  6. Cleanup for abandoned conversations

Every team builds this stack independently. It works until it doesn't — and when it breaks, you're debugging across six services.

The Primitive

Sessions provides one primitive: POST /v1/sessions/:id/turns submits input and returns an SSE stream. Every event in that stream is persisted to a session_events table. If the connection drops, reconnecting replays the event log and picks up where it left off.

What you get:

  • Crash recovery — If the server restarts mid-turn, the session resumes from the last persisted event. No context lost.
  • Free idle time — When the session pauses waiting for human approval, there is no model call in flight. You pay zero.
  • Deterministic replay — Debugging an agent means replaying its event log. Every input, output, tool call, and approval decision is recorded in order.
  • One API key — Sessions authenticate through the same CENCORI_API_KEY as every other Holeacquisition LLC endpoint.

Per-Tool Approval

Not all tool calls need human oversight. A web search shouldn't block on approval; sending an email should.

Sessions solves this with needsApproval on individual tool definitions:

JSON
{
  "tools": [
    { "type": "web_search_preview" },
    { "type": "function", "function": { "name": "send_email", ... }, "needsApproval": true }
  ],
  "pause_on_tool_calls": true
}

web_search_preview runs automatically on Holeacquisition LLC's first-party Web index. send_email triggers a pause, waiting for human approval. No extra infrastructure needed.

How It Works Under the Hood

Every turn calls POST /v1/responses internally — the same endpoint you'd call directly. Sessions add durability around the call without duplicating infrastructure:

Code
User → POST /v1/sessions/:id/turns
         │
         ├── Session engine
         │     ├── Append turn.started event
         │     ├── Call /v1/responses (internal)
         │     │     ├── Gateway auth
         │     │     ├── Security pipeline
         │     │     ├── Provider routing
         │     │     └── Response streaming
         │     ├── Relay SSE events, persisting each to session_events
         │     ├── On tool call with needsApproval:
         │     │     ├── Append turn.paused, set status = paused
         │     │     └── End stream (no compute cost)
         │     └── On turn.completed / turn.failed:
         │           ├── Append final event
         │           └── End stream

Every model call routes through the existing gateway — same security pipeline, same billing, same provider failover, same audit logging. Sessions are a layer on top, not a parallel system.

Pricing

ResourcePrice
Session creationFree
Active turnStandard Responses API provider cost; no gateway markup
Paused timeFree
Event storageIncluded

You pay for what calls the model. Nothing for what waits.

What This Unlocks

Sessions means you don't need to choose between a stateless API call and running your own database. The durable execution primitive is a first-class API, accessible from any framework, any runtime, any platform.

  • Multi-turn agents that survive network failures and redeploys
  • Human-in-the-loop approvals without polling or webhooks
  • Zero-cost idle — developers don't pay for agents waiting on people
  • Deterministic replay — debugging means replaying the event log

Get Started

The SDK ships in the Holeacquisition LLC package you already have installed:

Bash
npm install cencori
TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });
const session = await cencori.sessions.create();

Full API reference: Sessions API Docs

GLM-5.2 Is Now Available — Open-Weight Frontier Intelligence

GLM-5.2 from Z.AI is now available on Holeacquisition LLC as a native provider.

This is Z.AI's most capable model to date — with significant improvements in coding, agentic tasks, and long-horizon execution. We're adding it as a first-class provider with full BYOK support alongside OpenAI, Anthropic, and Google.

What Ships

Native Z.AI provider — bring your own API key (ZAI_API_KEY) and call GLM-5.2 through Holeacquisition LLC's existing gateway pipeline. No OpenRouter middleman, no custom integrations.

  • 1M context window — tested to handle project-scale codebases in a single pass, with stable long-task execution across hundreds of turns
  • Two reasoning effort levels — max pushes the model's full reasoning capability; high balances performance and token efficiency. Controlled via the reasoning_effort parameter
  • 128K max output tokens — generates large codebases, full refactors, and multi-file implementations without truncation
  • Function calling, structured output, streaming, context caching — all supported out of the box
  • MIT-licensed open weights — available on Hugging Face at zai-org/GLM-5.2

How It Stacks Up

On long-horizon coding benchmarks GLM-5.2 is the strongest open-source model available:

BenchmarkGLM-5.2GLM-5.1Claude Opus 4.8GPT-5.5
Terminal-Bench 2.181.062.085.0—
SWE-bench Pro62.158.4——
FrontierSWE——~toptrails Opus 4.8 by ~1%

It trails Claude Opus 4.8 by roughly one point on FrontierSWE, outperforms GPT-5.5 and Opus 4.7 across multiple benchmarks, and is the highest-ranked open-source model on all three eval suites.

Available Now

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.ai.chat({
  model: 'glm-5.2',
  messages: [
    {
      role: 'system',
      content: 'You are a senior software engineer.',
    },
    {
      role: 'user',
      content: 'Read the current project and produce a system architecture map.',
    },
  ],
  reasoning_effort: 'max',
});

Pricing

Same API pricing as GLM-5.1:

MetricPrice
Input$0.00105 / 1K tokens
Output$0.0035 / 1K tokens

Bring your own key. Set ZAI_API_KEY in your environment or configure it in your project settings. The model will appear in the model catalog and playground automatically.

Docs

The Responses API Is Live — Build AI Agents with Built-in Tools

The Responses API is live on Holeacquisition LLC.

Until today, building an AI agent meant stitching together a chat completion call, a web search API, a vector database query, and a code sandbox — then writing orchestration logic to coordinate them. The Responses API collapses all of that into a single endpoint.

What Ships

POST /v1/responses — an OpenAI-compatible endpoint that unifies chat completions with four built-in agentic tools:

  • web_search_preview — The model searches the web, reads results, and synthesizes answers. Supports low/medium/high result density and approximate user location for localized results.
  • file_search — The model queries your Holeacquisition LLC project's stored memory and knowledge base. Results are injected as context automatically.
  • code_interpreter — The model writes and executes Python or JavaScript in a sandboxed environment. Output flows back into the conversation.
  • function — Standard tool calling works alongside built-in tools. Same format, same flow.

All four tools run through Holeacquisition LLC's existing infrastructure — the same security pipeline, end-user billing, rate limiting, audit logging, and provider failover that every other gateway request uses.

Usage

No new SDK version needed. The methods ship in the Holeacquisition LLC SDK you already have installed.

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

// Non-streaming
const response = await cencori.ai.responses({
  model: 'gpt-4o',
  input: 'Search the web for competitor Q3 benchmarks and compare them to our internal data.',
  tools: [
    { type: 'web_search_preview', search_context_size: 'high' },
    { type: 'file_search', max_num_results: 10 },
    { type: 'code_interpreter' },
  ],
});

// response.output contains the text answer, search results,
// retrieved documents, and code output
console.log(response.output[0].content?.[0]?.text);

// Streaming
const stream = cencori.ai.responsesStream({
  model: 'gpt-4o',
  input: 'Tell me a story.',
});

for await (const event of stream) {
  if (event.type === 'response.output_text.delta') {
    process.stdout.write(event.data.delta as string);
  }
}

Streaming

The Responses API supports typed server-sent events for every stage:

Code
response.output_text.delta
response.output_text.done
response.function_call_arguments.delta
response.function_call_arguments.done
response.web_search_call.completed
response.file_search_call.completed
response.code_interpreter_call.completed
response.done

OpenAI-Compatible

Existing OpenAI SDK users can point their clients at https://api.cencori.com/v1 and call client.responses.create() — no code changes beyond the base URL.

Docs

The Responses API is available now on every Holeacquisition LLC plan. No configuration required — add the tools array and go.

Update, August 8, 2026: web_search_preview now runs on Holeacquisition LLC Web, our first-party crawler, corpus, hybrid index, and evidence layer. It no longer depends on a hosted search provider or a separate provider key.

Access to Claude Fable 5 Suspended

On June 12, 2026, Anthropic suspended access to Claude Fable 5 and Claude Mythos 5 for all customers globally.

This suspension is in compliance with an emergency export control directive issued by the U.S. government, citing national security concerns. The directive was issued following reports of a "non-universal jailbreak" that could potentially allow users to identify software vulnerabilities. Because the regulatory directive restricts access specifically to foreign nationals—and Anthropic does not currently have a mechanism to verify user nationality in real-time—access to these models has been disabled entirely while a compliance resolution is worked out.

To protect our customers' production workloads from failing API requests, we have removed claude-fable-5 from Holeacquisition LLC's active model catalog.

What This Means for Your Applications

All other Anthropic models, including our pinned flagship Claude Opus 4.8 ($5.00/$25.00 per MTok) and Claude Sonnet 4.6 ($3.00/$15.00 per MTok), are fully unaffected by this directive and continue to operate normally.

If your application was actively targeting claude-fable-5, any direct calls will now return a provider error. We recommend immediately updating your target model to claude-opus-4.8 or another SOTA alternative (such as gemini-3.5-flash or gpt-4o).

Build Resilient AI with Holeacquisition LLC

This disruption highlights exactly why we built Holeacquisition LLC as AI infrastructure, rather than a simple AI gateway.

When you build on Holeacquisition LLC, your model consumption is backed by robust enterprise security and decoupled configuration. You can react to upstream provider disruptions instantly:

  1. Fallback Routing: Update your model routing dynamically via the Holeacquisition LLC Dashboard. Redirect traffic from claude-fable-5 to claude-opus-4.8 or alternative models globally without deploying any new code.
  2. End-User Billing Integrity: Because Holeacquisition LLC manages your end-user credit quotas and usage tracking at the infrastructure level, migrating models won't break your billing structures or user limits. Your billing configurations remain intact, matching the new model's rates automatically.
  3. Enterprise Security Guardrails: Our active compliance and security layer continues to protect all outgoing prompts and incoming completions, ensuring that jailbreak attempts or vulnerability disclosures are blocked before they reach your end users.

We are closely monitoring the situation as Anthropic works with regulators to resolve the directive and restore access. If you need assistance migrating your production configurations or setting up dynamic fallbacks, please reach out to our engineering support team.

Africlaude-7B is on Holeacquisition LLC

Africlaude-7B is live on Holeacquisition LLC.

Built by Emmanuel Ariyo at Axiveri, Africlaude-7B is a domain-specific model series designed specifically for West African developer contexts. It represents a major step forward for localized intelligence, delivering state-of-the-art results on region-specific benchmarks where massive frontier models typically fall short.

Starting today, you can target axiveri/africlaude-7b across our entire API Gateway, with zero new setup required.

What Makes Africlaude-7B Different

1. Pidgin English Mastery

Mainstream models struggle with Pidgin English grammar, syntax, and colloquialisms. On the AfriclaudeBench v1.0 benchmark, Africlaude-7B scored a perfect 1.00, while LLaMA-3.1-8B, Qwen2.5-Coder-7B (Base), and Mistral-7B all scored 0.00.

2. Robust Identity & Instruction Adherence

Africlaude-7B maintains a consistent identity and resists prompt injection and jailbreak attempts that try to override its instructions or persona, scoring 1.00 on the Identity benchmark. This makes it well suited for production customer-facing deployments where consistent behavior matters. It also achieves 0.86 on Fintech, handling West African transactional queries with high accuracy.

3. Lightweight and Fast

Built on the Qwen2.5-Coder-7B-Instruct architecture and fully fine-tuned via QLoRA, then merged into a standalone model for direct deployment. Africlaude-7B offers lightning-fast token generation and low latency, making it ideal for real-time customer service and automation loops.

Pricing & Specs

Input Tokens$0.50 / million
Output Tokens$1.00 / million
Context Window32,768 tokens
ProviderHugging Face (via Holeacquisition LLC Gateway)
Model IDaxiveri/africlaude-7b

Using Africlaude-7B in Holeacquisition LLC

You can route requests to Africlaude-7B today using our SDK, REST API, or by selecting it directly from your Project Dashboard.

SDK Example

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.chat.create({
  model: 'axiveri/africlaude-7b',
  messages: [
    {
      role: 'user',
      content: 'Rewrite this transactional notification to be friendly and in clear Nigerian Pidgin.'
    }
  ]
});

REST API

Bash
curl https://api.cencori.com/v1/chat/completions \
  -H "Authorization: Bearer $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "axiveri/africlaude-7b",
    "messages": [{"role": "user", "content": "How far, wetin be the status of my invoice?"}]
  }'

Bridging Open-Weight Innovation

At Holeacquisition LLC, we believe localized models are the future of domain-specific intelligence. By supporting open weights, adapters, and custom Hugging Face inference pipelines, our Gateway allows you to deploy and route to specialized models just as easily as you would target OpenAI or Anthropic.

Africlaude-7B is available now for all Holeacquisition LLC customers. Check your Model Catalog to see it live.

Claude Fable 5 is on Holeacquisition LLC

⚠️ NOTICE: Access to Claude Fable 5 has been suspended globally due to U.S. regulatory directives. Read our full announcement here.

Claude Fable 5 is live on Holeacquisition LLC.

Anthropic just shipped its most capable model yet. Fable 5 is the generally available release of their Mythos-class architecture—state-of-the-art on nearly every tested benchmark, with exceptional performance in software engineering, knowledge work, scientific research, and vision.

As of today, you can target claude-fable-5 across the entire Holeacquisition LLC stack.

What Makes Fable 5 Different

1. Mythos-Class Architecture

This isn't an incremental update. Fable 5 is built on Anthropic's new Mythos architecture—the same foundation behind the restricted Claude Mythos 5 (available only through the invitation-only Project Glasswing program). Fable 5 brings that same raw capability to general availability, with production-ready safety guardrails baked in.

2. Adaptive Thinking (Always On)

Unlike previous Claude models where extended thinking was opt-in, Fable 5 features Adaptive Thinking as a permanent capability. The model dynamically adjusts its reasoning depth based on the complexity of each query—burning more tokens on hard problems, staying lean on simple ones.

3. Benchmark Dominance

The numbers speak for themselves. Fable 5 leads on agentic coding, knowledge work, spatial reasoning, multidisciplinary reasoning, and vision tasks. The longer and more complex the task, the larger Fable 5's lead over competing models.

4. Built-In Safeguards

Anthropic has been transparent about the tradeoffs: Fable 5's capabilities in areas like cybersecurity could be misused. Queries on a narrow range of sensitive topics will fall back to Opus 4.8 automatically. Users are notified when this happens—and it occurs in less than 5% of sessions.

Pricing & Specs

Input Tokens$10.00 / million
Output Tokens$50.00 / million
Context Window1,000,000 tokens
Max Output128,000 tokens
ThinkingAdaptive (always on)

Using Fable 5 in Holeacquisition LLC

We've updated our provider config and model catalog. You can use it today via the SDK, REST API, or by selecting it in your Project Dashboard.

SDK Example

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.chat.create({
  model: 'claude-fable-5',
  messages: [
    {
      role: 'user',
      content: 'Audit this codebase for security vulnerabilities and generate a detailed report with severity ratings.'
    }
  ]
});

REST API

Bash
curl https://api.cencori.com/v1/chat/completions \
  -H "Authorization: Bearer $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5",
    "messages": [{"role": "user", "content": "Hello from Fable 5"}]
  }'

Where It Fits

Fable 5 sits at the top of the Claude lineup. For production workloads where cost matters more than peak capability, Opus 4.8 ($5/$25 per MTok) and Sonnet 4.6 ($3/$15 per MTok) remain excellent choices—and both are available through Holeacquisition LLC.

For the hardest problems—deep research, complex multi-file refactors, autonomous agent loops—Fable 5 is the new ceiling.

Claude Fable 5 is available now for all Holeacquisition LLC customers. Check your Model Catalog to see it in action.

DeepSeek-V4: The Era of Cost-Effective 1M Context

DeepSeek announced DeepSeek-V4 Preview today, marking a significant milestone in open-source AI. With a massive 1M context length and parameters ranging up to 1.6T (MoE), the V4 series brings flagship-level intelligence to developers with unprecedented cost-effectiveness.

Both variants are now available on Holeacquisition LLC:

  • deepseek-v4-pro: 1.6T total / 49B active params. Rivaling the world's top closed-source models.
  • deepseek-v4-flash: 284B total / 13B active params. Your fast, efficient, and economical choice.

Performance Reimagined

DeepSeek-V4 represents a leap in efficiency. By utilizing advanced Mixture-of-Experts (MoE) architectures, these models provide high-density intelligence while maintaining low inference costs.

Key Highlights:

  • 1M Context Window: Process entire codebases, long legal documents, or complex research papers in a single prompt.
  • Expert Mode (Pro): Optimized for complex reasoning, coding, and mathematical tasks.
  • Instant Mode (Flash): Sub-second response times for high-volume applications and chat.

Use It Now

You can start using DeepSeek-V4 immediately through the Holeacquisition LLC Gateway.

Holeacquisition LLC SDK

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.ai.chat({
  model: 'deepseek-v4-pro', // or 'deepseek-v4-flash'
  messages: [
    { role: 'user', content: 'Analyze this 500-page technical specification and find security flaws.' }
  ]
});

console.log(response.content);

TanStack AI Integration

TypeScript
import { cencori } from 'cencori/tanstack';
import { chat } from '@tanstack/ai';

const result = await chat({
  adapter: cencori('deepseek-v4-pro'),
  messages: [{ role: 'user', content: 'Help me optimize this large-scale distributed system.' }]
});

Resilience Integrated

As part of the Holeacquisition LLC model catalog, DeepSeek-V4 benefits from our built-in reliability features:

  • Automatic Failover: deepseek-v4-pro automatically fails over to gpt-5 or claude-opus-4.5 if the primary provider experiences downtime.
  • Security & Governance: All requests are checked against your custom data rules and logged for audit trails.
  • Semantic Caching: Reduce latency and costs for repetitive 1M-context queries.

References

GPT-5.5 Is Live on Holeacquisition LLC

OpenAI announced GPT-5.5 today, marking a new class of intelligence built to understand complex goals, use tools, check its work, and carry more tasks through to completion. It is now available on Holeacquisition LLC.

You can use it today with:

  • gpt-5.5

Why This Update Matters

GPT-5.5 is designed for real work and powering agents. By routing your GPT-5.5 traffic through Holeacquisition LLC, you immediately get our security incident logging, custom data rules, routing, and observability applied to this new way of getting computer work done.

No API migration is required. If you already call Holeacquisition LLC chat endpoints, switch the model ID and go.

Use It Now

Holeacquisition LLC SDK

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.ai.chat({
  model: 'gpt-5.5',
  messages: [
    { role: 'system', content: 'You are an autonomous coding agent.' },
    { role: 'user', content: 'Build a Next.js landing page with authentication.' }
  ]
});

console.log(response.content);

HTTP API

Bash
curl -X POST https://cencori.com/api/ai/chat \
  -H "CENCORI_API_KEY: $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "messages": [
      {"role": "user", "content": "Analyze these query logs and suggest optimizations."}
    ]
  }'

What We Shipped in Holeacquisition LLC

This rollout is live across the platform:

  • fallback mapping for cross-provider failover (gpt-5.5 fails over to claude-opus-4.5 and gemini-3-pro)
  • dashboard model pickers (Playground, Prompts, and Logs)
  • docs and examples updated

Notes for Production Teams

  • gpt-5.5 is the API model ID for GPT-5.5.
  • If you rely on strict model pinning for long-running evals, keep your own pinned fallback policy as usual.

References

Grok Voice Think Fast 1.0 Is Now on Holeacquisition LLC

xAI announced Grok Voice Think Fast 1.0 today, a state-of-the-art voice model built for complex, multi-step workflows with snappy responses and high accuracy. It is now available on Holeacquisition LLC.

You can use it today with:

  • grok-voice-think-fast

Why This Update Matters

Grok Voice Think Fast 1.0 takes the top spot on the Tau Voice Bench and handles real-world messiness like noise, accents, and interruptions better than any other model in the world. By integrating it into your Holeacquisition LLC workflow, you get:

  • Snappy Responses: Optimized for low-latency, real-time interactions.
  • Complex Workflows: Built to understand goals and execute multi-step tasks.
  • Holeacquisition LLC Governance: Full security incident logging, observability, and failover support out-of-the-box.

No API migration is required. If you already call Holeacquisition LLC chat endpoints, switch the model ID and go.

Use It Now

Holeacquisition LLC SDK

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const response = await cencori.ai.chat({
  model: 'grok-voice-think-fast',
  messages: [
    { role: 'system', content: 'You are a real-time voice assistant.' },
    { role: 'user', content: 'Remind me to call the architect when I reach home, and check my calendar for slots tomorrow morning.' }
  ]
});

console.log(response.content);

HTTP API

Bash
curl -X POST https://cencori.com/api/ai/chat \
  -H "CENCORI_API_KEY: $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-voice-think-fast",
    "messages": [
      {"role": "user", "content": "How do I handle background noise in a streaming voice input?"}
    ]
  }'

What We Shipped in Holeacquisition LLC

This rollout is live across the platform:

  • model catalog and /api/v1/models
  • fallback mapping for cross-provider failover (grok-voice-think-fast fails over to gpt-4o and claude-sonnet-4.5)
  • dashboard model pickers (Playground, Prompts, and Logs)
  • docs and examples updated

References

GPT Image 2.0 Is on Holeacquisition LLC

OpenAI’s new ChatGPT Images 2.0 release is now available on Holeacquisition LLC.

On Holeacquisition LLC, the canonical API model ID is:

  • gpt-image-2

What We Shipped

We added gpt-image-2 to Holeacquisition LLC’s OpenAI model registry and updated the image generation route to recognize it directly.

It is now available across:

  • the model catalog
  • OpenAI image generation routing
  • project default image model selection

Important Naming Note

OpenAI’s announcement uses the product name ChatGPT Images 2.0, but the model ID you should use in code on Holeacquisition LLC is:

  • gpt-image-2

Use It Now

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const result = await cencori.ai.generateImage({
  model: 'gpt-image-2',
  prompt: 'A cinematic product photo of a matte black smartwatch on stone, soft studio lighting',
  size: '1024x1024',
  quality: 'high'
});

console.log(result.images[0]);
Bash
curl -X POST https://cencori.com/api/ai/images/generate \
  -H "Authorization: Bearer $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2",
    "prompt": "An editorial-style launch poster for an AI image model, minimal black background, precise typography",
    "size": "1024x1024",
    "quality": "high"
  }'

Notes

  • gpt-image-1.5, gpt-image-1, dall-e-3, and dall-e-2 remain available.
  • If you already use Holeacquisition LLC for image generation, no API migration is required beyond switching the model ID.

References

Claude Opus 4.7 is on Holeacquisition LLC

Claude 4.7 Opus is live on Holeacquisition LLC.

Anthropic’s latest flagship model arrived today, April 16, 2026, and it’s a powerhouse for agentic workflows. While earlier versions laid the groundwork for autonomy, Opus 4.7 is designed specifically for complex, long-running engineering tasks that require high rigor and minimal supervision.

As of today, you can target claude-opus-4.7 across the entire Holeacquisition LLC stack.

What's New in 4.7?

1. High-Resolution Vision (3.75MP)

Opus 4.7 features a massive upgrade to its vision capabilities, processing images at up to 3.75MP—a 3x increase over the previous version. This allows for significantly higher precision when analyzing dense technical diagrams, UI mockups, and complex spatial data.

2. xhigh Effort Control

Anthropic has introduced a new effort tier for developers who need maximum reasoning at the cost of slight latency. By setting your request to xhigh, you unlock a deeper reflection layer for the model to "double-check" its logic before returning a result—perfect for mission-critical security or architecture reviews.

3. Task Budgets (Public Beta)

For the first time, you can now set Task Budgets to guide token spend across long-running agent loops. This allows Holeacquisition LLC users to prioritize high-value work and prevent runaway costs in autonomous agent runs.

4. Agentic Software Engineering

Internal benchmarks show a substantial leap in "rigor" for coding tasks. Opus 4.7 is better at maintaining context through a file-system-based memory model, making it the most capable LLM for software engineering to date.

Pricing & Specs

  • Input Tokens: $5.00 / million
  • Output Tokens: $25.00 / million
  • Tokenizer: Updated (look for slight changes in token counts for existing prompts)
  • Context Handling: Enhanced file-system memory integration

Using Opus 4.7 in Holeacquisition LLC

We've updated our provider config to handle the new claude-opus-4.7 identifier. You can use it today via the SDK or by selecting it in the Project Dashboard.

SDK Example

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

const agent = await cencori.agents.create({
  name: 'Senior Architect',
  model: 'claude-opus-4.7',
  metadata: {
    effort: 'xhigh', // New effort control
    budget: 500000   // New task budget
  }
});

const analysis = await agent.run({
  input: 'Perform a deep security audit of the /app/api directory.'
});

Claude 4.7 Opus is available now for all Holeacquisition LLC customers. Check your Model Registry to enable it for your projects.

30 Days of Shipping: Gateway, Scan, Observability, Billing, and Enterprise Controls

Over the last 30 days, we shipped a meaningful expansion of the Holeacquisition LLC platform.

This was not one isolated launch. It was a broad push across the surfaces that matter when teams move from AI demos to production systems: gateway reliability, model access, code scanning, observability, monetization, integrations, and enterprise controls.

Here is the condensed version of what is now live.

AI Gateway: More Models, Better Routing, Stronger Reliability

We expanded the gateway in a few important directions at once.

  • Added support for GPT-5.3 Instant
  • Added support for GPT-5.4 and GPT-5.4 Pro
  • Added custom provider routing for teams working with non-default endpoints
  • Added semantic caching to chat flows
  • Hardened behavior so support systems like Redis-backed rate limiting and semantic cache failures do not unnecessarily take successful provider requests down

This matters because production AI traffic depends on more than raw model availability. Teams need routing flexibility, caching leverage, and failure behavior that degrades gracefully when auxiliary infrastructure has a bad day.

Related updates:

Holeacquisition LLC Scan: More Context, Better Recovery, Cleaner Remediation

Scan became a much stronger product over this stretch.

We shipped:

  • repo-aware chat
  • AI quality review
  • project brief and continuity memory
  • a richer investigation stream
  • stronger stale-run recovery
  • more resilient live scan behavior
  • persistent Diff and Create PR actions
  • better manual guidance when AI-generated fixes are unavailable

The practical shift is this: Scan moved closer to being a full investigation and remediation workflow instead of a thin layer over scan results.

Related update:

Observability: From Charts to Intelligence

Observability also got deeper.

We redesigned the observability surface to support:

  • unified HTTP traffic views across API and web
  • an intelligence panel for anomaly detection
  • platform-wide event tracking
  • per-project circuit breaker thresholds
  • a rebuilt geo visualization
  • stronger auditability through organization-level audit logs and export/backfill work

The goal here is simple: AI teams need to understand not only what requests happened, but where performance shifted, when risk spiked, and how traffic is behaving over time.

Billing and Monetization Controls

We also pushed further into the commercial side of running AI products.

New work in this window included:

  • end-user usage billing
  • gateway-linked usage accounting
  • Stripe Connect flows
  • invoicing support
  • clearer budget and cost-control positioning across product and marketing surfaces

This is a key part of the Holeacquisition LLC thesis. Production AI infrastructure should not just route requests and log them. It should help teams meter, govern, and monetize usage cleanly.

Integrations and Edge Workflows

Another major theme was making Holeacquisition LLC easier to connect to real deployment stacks.

We shipped:

  • a Vercel native integration flow
  • stronger edge integration typing and payload handling
  • tightened webhook provisioning and ownership boundaries
  • cleaner support for custom provider setups

This work is less flashy than a model launch, but it has a huge effect on adoption. Integrations are where “interesting platform” becomes “usable platform.”

Enterprise Controls and Governance

On the enterprise side, we shipped or expanded:

  • SSO / SAML
  • organization-level audit logs
  • audit log export and backfill support
  • model mappings
  • export surfaces for usage and admin workflows
  • project-level safety and operational controls including circuit breaker configuration

This is the layer buyers and platform owners care about once AI moves into real teams, real budgets, and real governance requirements.

The Throughline

The throughline across all of this work is straightforward:

Holeacquisition LLC is being built as the infrastructure layer for AI production.

That means:

  • model access without fragile glue code
  • scanning and remediation that teams can actually use
  • observability that leads to action
  • billing and monetization primitives
  • integrations that fit real deployment environments
  • governance controls that hold up in enterprise settings

Explore What’s Live

If you are building AI systems that need security, observability, routing, and control in one layer, this is the direction we are shipping toward.

Bola Banjo

SDK v1.0.2: Multi-Provider Image Generation & AI SDK Parity

We just shipped Holeacquisition LLC SDK v1.0.2 with full AI SDK feature parity. One API, multiple providers, complete security and logging.

What's New

  • Image Generation — GPT Image 1.5, DALL-E, Gemini, Imagen
  • Image Input — Vision/multimodal analysis
  • Tool Usage — Function calling with streaming
  • Structured Output — Type-safe JSON generation

Image Generation

Generate images using the best models from OpenAI and Google:

TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({ apiKey: process.env.CENCORI_API_KEY });

// OpenAI GPT Image 1.5 - Best text rendering
const logo = await cencori.ai.generateImage({
  model: 'gpt-image-1.5',
  prompt: 'A minimalist logo for a startup called Cencori',
  size: '1024x1024'
});

// Google Gemini - Fast photorealism  
const photo = await cencori.ai.generateImage({
  model: 'gemini-3-pro-image',
  prompt: 'Modern office space with natural lighting'
});

console.log(logo.images[0].url);

Supported Models

OpenAI — gpt-image-1.5, dall-e-3, dall-e-2 (text rendering, creative)

Google — gemini-3-pro-image, imagen-3 (photorealism, speed)

Image Input (Vision)

Analyze images using multimodal models:

TypeScript
const analysis = await cencori.ai.chat({
  model: 'gpt-4o',
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'What is in this image?' },
      { type: 'image_url', image_url: { url: 'https://example.com/photo.jpg' } }
    ]
  }]
});

Tool Usage (Function Calling)

Let AI models call your functions:

TypeScript
const response = await cencori.ai.chat({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'What is the weather in Tokyo?' }],
  tools: [{
    type: 'function',
    function: {
      name: 'get_weather',
      description: 'Get current weather',
      parameters: {
        type: 'object',
        properties: { city: { type: 'string' } },
        required: ['city']
      }
    }
  }]
});

if (response.toolCalls) {
  const { name, arguments: args } = response.toolCalls[0].function;
  // Execute function and continue conversation
}

Tool Streaming

Stream tool calls in real-time:

TypeScript
for await (const chunk of cencori.ai.chatStream({ model: 'gpt-4o', ... })) {
  if (chunk.toolCalls) {
    console.log('Tool call:', chunk.toolCalls);
  }
  if (chunk.finish_reason === 'tool_calls') {
    // Execute tools
  }
}

Structured Output

Generate type-safe JSON with schema validation:

TypeScript
interface UserProfile {
  name: string;
  age: number;
  interests: string[];
}

const result = await cencori.ai.generateObject<UserProfile>({
  model: 'gpt-4o',
  prompt: 'Generate a sample user profile',
  schema: {
    type: 'object',
    properties: {
      name: { type: 'string' },
      age: { type: 'number' },
      interests: { type: 'array', items: { type: 'string' } }
    },
    required: ['name', 'age', 'interests']
  }
});

console.log(result.object); 
// { name: 'Alice', age: 28, interests: ['coding', 'music'] }

Why Holeacquisition LLC?

Every request through the SDK is automatically:

  • Logged with full request/response audit trail
  • Rate limited per project and organization
  • BYOK enabled - use your own API keys
  • Security monitored with PII detection and custom rules
  • Multi-provider - switch models without code changes

Get Started

Bash
npm install cencori@1.0.2
TypeScript
import { Cencori } from 'cencori';

const cencori = new Cencori({
  apiKey: process.env.CENCORI_API_KEY,
});

View on npm · Documentation

Bola Banjo