Point your existing SDKs at your own models.

A drop-in OpenAI-compatible /v1 API sits in front of every model your instance serves. Change the base URL, issue yourself a token, and leave the rest of your client exactly as it is.

What changes, and what does not #

Two lines of configuration. Model names become the deployments in your own catalogue, and the credential becomes a token you mint and revoke yourself. The point is continuity rather than novelty: the tools, agent frameworks and editors your teams already depend on keep working, while the weights, the accelerators and the decision about where a request may run all move inside your boundary.

Call your own model with the OpenAI Python SDK · Python

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://agentycs.example.com/v1",
    api_key=os.environ["AGENTYCS_API_TOKEN"],
)

stream = client.chat.completions.create(
    model="chat-large",
    messages=[
        {"role": "user", "content": "Which sites are behind on inspections?"},
    ],
    stream=True,
)

for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

Two lines change: the base URL becomes your instance, and the key becomes a token you minted. The model name is a deployment from your own catalogue, not a vendor's.

The same request over HTTP · Shell

curl https://agentycs.example.com/v1/chat/completions \
  -H "Authorization: Bearer $AGENTYCS_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "chat-large",
    "messages": [{"role": "user", "content": "Summarise this quarter."}],
    "stream": true
  }'

Anything that can speak to an OpenAI-compatible endpoint can speak to your instance, including agent frameworks and editors you have already standardised on.

Import a model once. Serve it for as long as you own the hardware, with nothing to call home to.

More than chat #

The serving plane is multi-modal, and each model class is served by the runtime that runs it best rather than one forced backend.

Text generation: Streaming completions with continuous batching and KV-cache management underneath.
Embeddings: The same interface feeds the hybrid search indexes over your own data.
Speech to text: Transcription served on the same fleet, under the same policy.
Vision: Image-capable models served alongside text, with capability flags in the catalogue.

Embed with the same client, on the same interface · Python

vectors = client.embeddings.create(
    model="embed-default",
    input=["Site FAW-014 failed its pressure test."],
)

print(len(vectors.data[0].embedding))

The same client object, a different deployment from your catalogue. This is the interface the platform's own hybrid search indexes are built on, so an embedding you generate and one the lakehouse generates come from the same model on the same accelerators.

You decide where a request runs #

Every request is authorised and policy-checked before any work is dispatched, then routed by capability, locality and load. A workspace can be restricted to models that never leave the cluster, or allowed to reach an approved external provider through the same interface.

Local accelerators, a remote or air-gapped site, or an approved external provider
Policy decides which models may serve a request and whether data may leave the cluster
External provider credentials are vault-referenced, never returned and never logged
An edge site keeps serving its loaded models even when the core is unreachable

List what your instance will actually serve you · Shell

$ curl -s https://agentycs.example.com/v1/models \
    -H "Authorization: Bearer $AGENTYCS_API_TOKEN" | jq -r '.data[].id'

chat-large
chat-small
embed-default
transcribe-default

Your catalogue, not a vendor's. Every id here is an open model somebody in your organisation imported and placed, and the list narrows to what policy permits this workspace to reach, so a token that cannot use a model cannot see it either.

Placed where it runs best #

Models are only scheduled onto accelerators whose architecture supports their kernels and numeric format, tensor-parallel groups stay on matching hardware, and per-accelerator memory is budgeted. Low-bit floating point is used where the hardware accelerates it and falls back gracefully where it does not.

Import an open model once; serve it forever, with no runtime dependency on an external host
Weights held in a content-addressed store you own, mirrored out to workers and edges
Required memory, numeric format and supported architectures inferred on import
Accelerators shared across workspaces with enforced isolation, or allocated exclusively

Credentials and accounting #

Programmatic access uses tokens you issue. They are stored only as hashes, exchanged for short-lived bearer credentials, and denied immediately on revocation or expiry.

Tokens minted, scoped and revoked from the model console, never carried in a URL
Signed capability tokens for machine-to-machine calls, verifiable against a published JWKS
Per-workspace and per-model usage rollups for capacity planning and chargeback
Top models, workspace and provider breakdowns computed over the lakehouse itself

Point your existing SDKs at your own models.

What changes, and what does not #

More than chat #

You decide where a request runs #

Placed where it runs best #

Credentials and accounting #

Keep going #

MCP and tools

APIs and protocols

Deployment models