Introducing Akumi

Akumi is the EU-sovereign, drop-in OpenAI-compatible API. You change one base URL and your prompts, models, and data stay in the EU, governed and audited from the first token.

Most teams building with AI in regulated markets make the same quiet decision every day. Ship the feature and route customer data to a US model, or hold the line on compliance and watch the roadmap stall. That decision usually falls to whoever is closest to the deadline, not to whoever owns the risk. We built Akumi so the safe path and the fast path are the same path.

Why we built it

The AI tooling that shipped over the last two years optimized for one thing: get a token out of a model as fast as possible, wherever that model happens to run. For a startup with no regulated data, that is fine. For a hospital, a bank, or a public-sector supplier in the EU, it is a standing liability. Pseudonymized data is still personal data under GDPR. A prompt that mentions a patient, a claimant, or an employee becomes a transfer the moment it leaves the region, and no amount of "we take privacy seriously" copy changes that.

The workaround most teams reach for is glue code: a routing layer, a scrubber, a spreadsheet of which model is allowed for which use case. It holds until someone adds a provider, forgets the scrubber, or reads the spreadsheet wrong. The compliance gap it leaves is invisible right up to the moment a DPO asks where a specific request went, and nobody can answer.

Akumi removes the tradeoff by making residency and governance properties of the platform, not habits you have to remember.

What you get on day one

With zero modules enabled you already get:

• One endpoint for every model. EU-sovereign models on EU infrastructure, and external providers like OpenAI, Anthropic, Google, and Mistral, all behind the same OpenAI-compatible API. Switch models by name, with no new SDKs.
• EU residency by default. Prompts, completions, and data stay in the region unless you explicitly allow otherwise.
• A fail-closed egress guard. A request never reaches an external or non-EU model unless you have allowed it, with personal data pseudonymized or a recorded acknowledgment on file. Off by default, enforced in code.
• A metadata-only audit trail. Every request records which model ran, in which region, through which provider, and why it was allowed. When someone asks where a request went, you answer with the log, not a guess.

It is a drop-in

If your code already talks to the OpenAI API, the change is one line:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.akumi.cloud/v1",
    api_key="ak_your_key",
)

Your existing calls keep working. Residency, the egress guard, and the audit trail apply from the first request, with no extra flags to set.

Or reach for the SDK

You do not need the SDK, but when you want typed, first-class access to the native surface, the official libraries for PHP, TypeScript, and Python are generated from the same OpenAPI spec that runs the API, so their methods and types never drift from the platform. The base URL is preconfigured, so you supply only a key:

import os
from akumi import Akumi

client = Akumi.from_api_key(os.environ["AKUMI_API_KEY"])

response = client.chat.create(params={
    "model": "mistral/mistral-small-2603",
    "messages": [{"role": "user", "content": "Summarize this contract."}],
})

The native client exposes more than chat: models to list what your organization can reach, memory and memoryThreads for long-term facts and conversations, and auditLogs to read the trail in code. Add-ons like the PII firewall, RAG, and guard ride as parameters on the chat call, so you reach them without leaving the same method.

Turn on what you need

EU-sovereign inference, metered and billed per use, is a complete product on its own. When your application needs more, turn modules on per tenant or per request:

• PII firewall. Pseudonymize personal data before any external call and restore it in the response. On by default.
• Guard. Enforce policy on inputs and outputs, with evasion detection.
• RAG. Ground answers in your own documents, held in EU-resident, walled-off collections.
• Memory. Long-term facts and conversation threads, injected before anything leaves the region.
• Cache. Return repeat and near-repeat answers without paying for inference again.
• Observability. Span-level traces and per-model metrics, EU-resident and metadata-only.

Each module is a node in one pipeline, metered on its own line, and none of them are required to send your first request.

Create a key, change one base URL, and see where your requests actually go.