Changelog

Maximo Atlas Preview is live on Cencori.

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.

From today, you can target maximo-atlas-preview across the entire Cencori stack.

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 Cencori users, this means a capable reasoning and coding model with no cost barrier during the preview window, and a strong budget option afterward.

SDK

import { Cencori } from 'cencori';

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

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

REST API

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-preview",
    "messages": [
      {"role": "user", "content": "Write a Python script to analyze server logs."}
    ]
  }'

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

• 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 Cencori chat endpoints, switch the model ID and go.
• The API model ID is maximo-atlas-preview.

• Maximo AI Platform
• Maximo AI Privacy Policy
• Maximo AI Terms of Service
• Cencori Models Catalog

Spitch is live on Cencori.

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

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

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

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

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 Cencori 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 is live on Cencori — 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 Cencori gateway with zero configuration changes — switch the model ID and go.

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.

SDK

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

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."}
    ]
  }'

• 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
• Cencori's security logging, data rules, and observability apply automatically

• 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
• Cencori's default OpenAI pricing for non-free models applies as fallback; configure per-model pricing via the dashboard or API for accurate cost tracking

• OpenAI: GPT-5.6 — Frontier intelligence that scales with your ambition
• OpenAI: Previewing GPT-5.6 Sol
• Cencori Models Catalog

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

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

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

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.

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 Cencori — no matter which model you picked — it just works.

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

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

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 Cencori dashboard would, without you writing the drag-drop logic, the compression, or the error UI.

This is the direction. The next few months of Cencori 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. Cencori ships you both.

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.

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 Cencori spend caps, logged with full metadata, and shows up in your usage dashboard next to your chat calls.

Same as any other Cencori model call: provider pricing plus your project's markup. Costs surface in the response payload (cost.cencoriChargeUsd) so you can meter or display them in your product. No separate Vision billing lane.

npm install cencori

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:

import { VisionUploader } from 'cencori/react';

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

That's it.

• Full API reference
• Build a Receipt Scanner — end-to-end tutorial
• Embed the VisionUploader Component — React integration guide

Documents is live on Cencori.

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.

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.

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

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

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:

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.

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

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

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

npm install cencori

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.

• Documents API reference
• Build a Contract Analyzer — end-to-end tutorial
• Vision endpoint — for standalone image analysis

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

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

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

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.

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 Cencori — no matter which model you picked — it just works.

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

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

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 Cencori dashboard would, without you writing the drag-drop logic, the compression, or the error UI.

This is the direction. The next few months of Cencori 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. Cencori ships you both.

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.

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 Cencori spend caps, logged with full metadata, and shows up in your usage dashboard next to your chat calls.

Same as any other Cencori model call: provider pricing plus your project's markup. Costs surface in the response payload (cost.cencoriChargeUsd) so you can meter or display them in your product. No separate Vision billing lane.

npm install cencori

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:

import { VisionUploader } from 'cencori/react';

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

That's it.

• Full API reference
• Build a Receipt Scanner — end-to-end tutorial
• Embed the VisionUploader Component — React integration guide

Crypto credit top-ups are live.

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

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.

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.

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

Claude Sonnet 5 is live on Cencori.

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.

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.

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

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

1. Decoupled Billing & Credit Quotas: Cencori manages credit allocations, end-user billing, and budget caps at the proxy level. When you transition your models to claude-sonnet-5, Cencori 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. Cencori'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 Cencori 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 Cencori

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

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 Cencori customers. Check your Model Catalog to see it in action.

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

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.

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.

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.

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

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:

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

web_search runs automatically. send_email triggers a pause, waiting for human approval. No extra infrastructure needed.

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

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.

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

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

The SDK ships in the Cencori package you already have installed:

npm install cencori

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 from Z.AI is now available on Cencori 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.

Native Z.AI provider — bring your own API key (ZAI_API_KEY) and call GLM-5.2 through Cencori'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

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

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.

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',
});

Same API pricing as GLM-5.1:

• GLM-5.2 Provider Docs
• GLM-5.2 on Z.AI
• Open Weights on Hugging Face
• Download weights

The Responses API is live on Cencori.

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.

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 Cencori 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 Cencori's existing infrastructure — the same security pipeline, end-user billing, rate limiting, audit logging, and provider failover that every other gateway request uses.

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

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);
  }
}

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

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

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.

• Building Agents with the Responses API — the front-facing guide
• Responses API Reference — full request/response schema

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

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 Cencori's active model catalog.

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

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

When you build on Cencori, 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 Cencori 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 Cencori 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 live on Cencori.

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.

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.

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

SDK Example

import { cencori } from '@cencori/sdk';

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

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?"}]
  }'

At Cencori, 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 Cencori customers. Check your Model Catalog to see it live.

⚠️ 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 Cencori.

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

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.

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

import { cencori } from '@cencori/sdk';

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

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"}]
  }'

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

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 Cencori customers. Check your Model Catalog to see it in action.

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 Cencori:

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

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.

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

Cencori SDK

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

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.' }]
});

As part of the Cencori 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.

• DeepSeek-V4 Tech Report
• Cencori Models Catalog

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

You can use it today with:

• gpt-5.5

GPT-5.5 is designed for real work and powering agents. By routing your GPT-5.5 traffic through Cencori, 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 Cencori chat endpoints, switch the model ID and go.

Cencori SDK

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

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."}
    ]
  }'

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

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

• OpenAI: Introducing GPT-5.5
• Cencori Models Catalog

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

You can use it today with:

• grok-voice-think-fast

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 Cencori workflow, you get:

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

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

Cencori SDK

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

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?"}
    ]
  }'

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

• xAI: Introducing Grok Voice Think Fast 1.0
• Cencori Models Catalog

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

On Cencori, the canonical API model ID is:

• gpt-image-2

We added gpt-image-2 to Cencori’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

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

• gpt-image-2

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]);

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"
  }'

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

• OpenAI: Introducing ChatGPT Images 2.0
• OpenAI API Docs: GPT Image 2

Claude 4.7 Opus is live on Cencori.

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

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

• 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

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

import { cencori } from '@cencori/sdk';

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 Cencori customers. Check your Model Registry to enable it for your projects.

Over the last 30 days, we shipped a meaningful expansion of the Cencori 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.

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:

• GPT-5.3 Instant on Cencori
• GPT-5.4 and GPT-5.4 Pro Are Live on Cencori

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:

• Introducing Cencori Scan

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.

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 Cencori thesis. Production AI infrastructure should not just route requests and log them. It should help teams meter, govern, and monetize usage cleanly.

Another major theme was making Cencori 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.”

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 across all of this work is straightforward:

Cencori 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

• Changelog
• AI Models
• AI Gateway
• Observability
• Scan
• Documentation

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

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

• 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

Generate images using the best models from OpenAI and Google:

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)

Analyze images using multimodal models:

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' } }
    ]
  }]
});

Let AI models call your functions:

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:

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

Generate type-safe JSON with schema validation:

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'] }

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

npm install cencori@1.0.2

import { Cencori } from 'cencori';

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

View on npm · Documentation

Today we're officially launching AI Gateway on Cencori.

AI teams should not need one SDK for provider access, another layer for failover, a separate security proxy, another tool for logs, and a custom billing system on top of all of it just to ship one product.

AI Gateway is our answer to that problem.

It gives you a single control point for AI traffic: one API for routing, reliability, security, observability, cost tracking, and monetization.

One API for Every Major Provider

Route traffic through one integration instead of wiring every provider separately.

• OpenAI
• Anthropic
• Google
• xAI
• Meta
• Mistral
• DeepSeek
• Groq
• Cohere
• Perplexity
• OpenAI-compatible endpoints and custom provider setups

The gateway supports native Cencori endpoints for chat, embeddings, images, audio, and moderation, plus an OpenAI-compatible endpoint for teams that want the fastest migration path.

const client = new OpenAI({
  apiKey: process.env.CENCORI_API_KEY,
  baseURL: "https://api.cencori.com/v1",
});

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello!" }],
});

You can also use the TypeScript SDK, Python SDK, streaming responses, tool calling, and Vercel AI SDK integrations on top of the same gateway layer.

Routing, Retries, and Automatic Failover

Reliability is handled in the gateway, not bolted onto each app.

• automatic retries for transient upstream failures
• fallback routing when a provider returns 429, 5xx, or times out
• model equivalence mapping across providers
• configurable fallback policies and retry limits
• circuit breakers that stop sending traffic into a degraded path
• load balancing across multiple provider keys to reduce hot spots and rate-limit pressure

That means your application can send requests to Cencori once, and Cencori handles the resilience work behind the scenes.

Built-In AI Security

Every request can be inspected before it reaches a model, and every response can be evaluated before it reaches your user.

• prompt injection and jailbreak detection
• PII scanning for prompts and responses
• content filtering across harmful categories
• unified moderation controls
• configurable actions to mask, redact, block, or allow with logging
• structured security errors and incident records for blocked requests

Cencori's security layer is designed for production systems where safety has to happen in real time, not as an afterthought.

Full Observability

AI Gateway ships with observability built in.

• request and response logs for every model call
• provider, model, status, token usage, latency, and time-to-first-token
• cost tracking per request with continuously updated provider pricing
• analytics for spend, throughput, latency percentiles, and error rates
• traces for multi-step workflows, agent runs, retrieval chains, and tool calls
• web telemetry so HTTP traffic and AI traffic can be viewed together
• export paths for enterprise teams that need raw data in their own systems

For most teams, this removes the need to stitch together a separate logging or AI observability product just to understand production traffic.

Billing and Monetization

The gateway does more than route traffic. It also helps teams control and monetize AI usage.

• built-in cost tracking
• rate limiting and usage governance
• spend visibility per request and per project
• end-user billing when you pass a user id through the gateway
• quota enforcement, rate plans, markup pricing, and invoices
• Stripe Connect support for payout flows
• Usage Events API for teams that want the billing layer even if they still call providers directly

If you already route traffic through Cencori, billing becomes dramatically simpler because usage, cost, and enforcement all happen in the same place.

Developer Platform and Open Integration Surface

AI Gateway is built to fit into existing stacks without forcing a rewrite.

• OpenAI-compatible chat endpoint
• TypeScript and Python SDKs
• support for streaming and tool calling
• API key management
• custom providers and model mappings
• Vercel AI SDK support
• clean migration path for teams moving from direct provider usage

The goal is simple: swap one base URL, keep shipping.

Compliance, Auditability, and Enterprise Controls

For teams moving AI into production, operational controls matter as much as model access.

AI Gateway ships with:

• audit logs for administrative changes
• security incident logging
• policy enforcement controls
• project-level governance
• compliance-ready records for teams that need traceability

This is what turns an AI proxy into production infrastructure.

Before AI Gateway, teams typically had to solve the same set of infrastructure problems over and over:

• how to route between providers
• how to survive provider outages
• how to inspect and block risky prompts
• how to understand latency and cost
• how to rate limit and meter usage
• how to charge end-users for AI features

That slows teams down and creates brittle systems.

AI Gateway makes Cencori the runtime control point for every model request. You integrate once. We handle the hard infrastructure layer behind it.

• AI Gateway
• Gateway Documentation
• Routing & Failover
• Observability
• End-User Billing
• Dashboard

This is the first major layer of the Cencori platform, and it is live now.