LLM / GenAI Integration

• Your app calls one typed client — never welded to one vendor's SDK; adding a provider is implementing one interface
• Cost governance built in — cached versus full-price input tracked first-class, with per-component cost accounting
• Typed streaming and tool calling — message deltas, tool-input deltas, and extended thinking mapped onto one clean event taxonomy
• The same seam every one of our agent and MCP offerings runs on — the foundation, handed to you to own

How it works

Most LLM integrations weld a product to one vendor's SDK on day one, and then the cost of switching — or even adding — a model provider is a rewrite. We build you the seam that makes the vendor a configuration choice instead. Your application calls one typed client; behind it sit interchangeable provider adapters for Anthropic, OpenAI, and Google Gemini. Adding a provider is implementing a single interface, not touching your product code.

The seam is real, not a thin wrapper. It carries a complete typed streaming event taxonomy (message deltas, tool-input deltas, extended thinking), a typed tool-calling model, and cache-aware cost accounting that tracks standard, cache-read, and cache-creation input as first-class components — each priced by its own rate, so your spend is governed rather than back-computed from a bill. Each adapter ships with real-API integration tests, plus a deterministic fake so your own tests can run offline.

This is also the foundation every one of our agent and MCP offerings runs on — when we say we own the plumbing, this is the plumbing. We build it through the D2D Line and hand it over.

Local and private models — what we can honestly say

We have a provider-agnostic seam, and a local or private model is a buildable adapter against that same seam. What we do not have is a shipped local-LLM product — there is no native local-model runtime we run today. If you need a local or private model, we build the adapter against the existing contract; we will never imply we already ship one.

What you own at the end

The client seam, the provider adapters, the cost accounting, and the test suite are yours — source and all. You are never welded to one vendor, there is no OPST runtime in the path, and your team can add a provider or swap a model without a rewrite.

FAQ

Do we have to pick a single provider? No — that is the whole point. You can run more than one, route by cost or capability, and add or drop a provider later as configuration.

Can you count tokens before a call? Yes, with a local pre-flight estimate so you can budget a call before it runs. Exact, authoritative counts come back from the provider after the call; the pre-flight number is a fast local estimate, and we are clear about which is which.

How is it priced? Fixed-scope, fixed-fee for the integration. The providers and the surface you need are pinned in the FRAME phase before any build starts.

• A provider-agnostic client seam delegating to any provider implementation — three live cloud adapters for Anthropic, OpenAI, and Google, each with real-API integration tests, plus a deterministic fake for offline testing.
• Cache-aware cost accounting — the usage model stores standard, cache-read, and cache-creation input components first-class, each priced by its own rate; cost accounting runs end to end against the real Anthropic API.
• A complete typed streaming event taxonomy and a typed tool-calling model, with the real Anthropic adapter yielding the events and converting tool definitions to the SDK's own shape.