Production systems
built on OpenAI.
OpenAI's embedding models and GPT-class models are a strong default for retrieval and for high-volume, cost-sensitive extraction work — one option in a stack we choose per project, not a default we reach for out of habit.
Serving UK and EU clients: GDPR, EU AI Act, and data residency are covered on our Trust & Safety page.
A default for retrieval,
a workhorse for extraction.
OpenAI is a closed-model API platform — you call its hosted endpoints, you don't get the weights, and there's no self-hosting path the way there is with Llama or Mistral's open releases. In exchange, it ships one of the widest model tier ranges of any provider: fast, cheap "mini" and "nano" variants alongside full frontier-class models and a separate o-series built specifically for harder, slower multi-step reasoning. That range is the actual reason we reach for it on certain jobs — not because it's a default, but because routing a request to the right tier is itself a cost and latency lever.
Its embedding models (the text-embedding-3 family) are a well-tested, widely compatible default for RAG retrieval, with a genuinely useful technical detail: they support configurable output dimensions via a technique related to Matryoshka representation learning, so you can shrink the embedding vector to cut storage and search cost without re-embedding your whole corpus from scratch. GPT-class models are a solid fit for structured extraction and high-volume, lower-complexity requests, particularly through JSON mode and function calling, where the model returns data in a schema rather than free text you have to parse and hope about.
The honest tradeoff against Claude or a self-hosted open model: no control over the weights, no on-premise option if a client's data residency requirements rule out any external API call at all, and you're exposed to OpenAI's own rate limits and occasional outages at the platform level. For projects where reasoning depth matters more than cost per call, we'll often route to Claude or a different model instead of forcing OpenAI into a job it isn't the best fit for — the same decision discipline we apply to every provider we work with, not special pleading for a favorite.
One more practical distinction worth knowing: OpenAI's API includes built-in tool-calling patterns and hosted conveniences — file search over uploaded documents, a code interpreter sandbox, structured outputs validated against a JSON schema — that reduce the amount of custom plumbing a team has to write compared to assembling the same capability from a raw completions endpoint. That convenience is real, but it's also part of what makes an un-abstracted integration harder to move off later, which is exactly why we don't call these hosted conveniences directly from application code.
We route to it for specific jobs, not as a house default — see our note on avoiding AI vendor lock-in for why we build every integration behind a provider abstraction instead of calling one SDK directly everywhere.
High-volume work,
priced to scale.
The cases where OpenAI tends to be the right call in our stack, and the detail work that makes it reliable at volume.
The embedding layer in RAG pipelines, often paired with ChromaDB for the vector store — with dimensionality tuned down from the default when storage and query latency matter more than squeezing out the last point of retrieval accuracy.
Pulling structured fields out of unstructured documents at volume using JSON mode and function calling, where a cheaper model tier handles the bulk of requests and a stricter schema check catches the cases where the model's output doesn't actually match what downstream systems expect.
Simple, high-volume requests go to a fast, cheap model tier; requests that need deeper reasoning get routed to a frontier or o-series model instead — decided per request, not hardcoded once for the whole system.
Retry and backoff logic, usage monitoring against OpenAI's tier limits, and a fallback path to a different provider for the rare but real cases where the API itself is degraded — treated as a production dependency with its own failure mode, not an edge case worth skipping until it happens once in front of a client.
One option
across several services.
OpenAI shows up as one of the models we route to across a few different kinds of builds, not a single dedicated service.
Embeddings and generation inside retrieval pipelines, where cost per query at volume is a real constraint and dimensionality tuning on the embedding model genuinely moves the number.
Structured extraction from contracts, forms, and unstructured documents at the volume this tier pricing is built for — cheaper models doing the bulk of the work, schema validation catching the exceptions.
Function calling and tool use for agents scoped to specific, well-defined actions, where reliable structured output matters more than raw reasoning depth.
Model monthly LLM/agent spend with sensitivity analysis before committing to a provider.
Before you
book a call.
The questions we get asked most about building with OpenAI — answered straight, no sales pitch.
Why use OpenAI instead of another provider?
We pick per project. OpenAI's embedding models are a strong, well-tested default for RAG retrieval, and GPT-class models are a solid fit for structured extraction and high-volume, lower-complexity requests where cost per call matters. For heavier reasoning, long-context work, or a client that needs the model self-hosted entirely, we'll often route to a different model instead — Claude, or a self-hosted Llama or Mistral deployment, depending on what the constraint actually is.
Are you locked into OpenAI once you build on it?
No — we build a thin provider abstraction into the architecture from the start specifically so that isn't true. See our note on avoiding AI vendor lock-in.
Which OpenAI model do you actually use, and how do you decide?
It depends on the request, not the project as a whole — we route simple, high-volume calls to a fast, cheap tier and reserve frontier or o-series reasoning models for requests that genuinely need deeper multi-step reasoning. Picking one model for an entire system usually means overpaying for the easy requests or underpowering the hard ones, and neither failure mode is obvious until the usage bill or the complaint about a wrong answer shows up.
How do you handle OpenAI's rate limits or downtime in production?
Retry logic with backoff, usage tracked against the account's actual rate-limit tier, and — for systems where an outage is unacceptable — a fallback to a different provider behind the same abstraction layer. We treat API availability as a dependency to design around, not an assumption.
What have you actually used OpenAI for?
Embeddings and generation in RAG pipelines, and structured extraction tasks such as pulling risk signals out of documents — the kind of high-volume, cost-sensitive work covered in our LLM inference cost reduction case study.
Tell us what
you're trying to build.
Book a 30-minute call — we'll tell you honestly whether OpenAI is the right model for your project, or whether something else is.