Past the demo,
into everyday use
We build features and products on the OpenAI API, with replies in the shape your code expects, a test set run before every model change, and requests built so the part that stays the same is reused, so every change is tested before your users see it.
Thanks, we’ll be in touch soon.
{{ heroStatus }}
You’re in good company
A few of the companies we’ve worked with.
When the demo became the product
Features on the OpenAI API often start as a demo that works. The product sends a request, its instructions, input and settings, to a model, and the model’s reply comes back as text.
Then the demo ships as it is: one long prompt edited by hand, replies read by matching their wording, one key shared by everything, the model named without a snapshot, the version that stays the same, no test set, and every request sending the same long instructions.
A new model words its replies a little differently and a parser breaks, the bill grows with use, and the model or the API it was built on reaches the shutdown date on the deprecations page.
None of this means the demo was wrong. It proved the idea.
Making it dependable is a different job: a test set, replies in a set shape, and settings chosen on purpose.
What we build
Requests set for each task, replies your code can read, tests before every change and costs kept in check, from the first feature to the ones that follow.
Requests set for each task
Instructions, examples and a model chosen for each job, the smallest one that passes your tests.
Replies in the shape your code expects
A schema for each reply, the shape it must take, so your product reads fields, not wording.
Tools that reach your systems
Actions the model can ask for in your own systems, with your code checking each one before it runs.
A test set from real cases
Examples with the answers you expect, run before any prompt, setting or model changes.
Cost and speed kept in check
Requests built so the part that repeats is reused, work that can wait sent at a lower priority, for less, and spend alerts and limits for each project.
Data and access settings
What’s stored and for how long, a project and key for each part of the product, and roles for who can change what.
Replies as they’re written, and long tasks
Replies shown as they arrive, and long tasks run in the background, with a message to your product when each is done.
Moves off retired models and APIs
Each move read in the guide OpenAI publishes for it, run on the test set, then switched.
Watching it once it’s live
Errors, refusals, cost per request and the replies people flag, reviewed with your team.
- Assistants that take actions in your systems?AI Agents
- Answers for customers and staff, from your own documents?AI Chatbots & Assistants
- Your product inside the assistants people use?MCP & Agent Integration
Reuse the part that stays the same
Most requests a product sends open the same way, with the same instructions and examples. OpenAI can reuse its work on an opening it has seen recently, so the reply starts sooner and the reused part costs less. Only an identical opening is reused, up to a breakpoint: a mark at the end of the reusable part.
On the current OpenAI models, the breakpoint lands at the end of the latest message by default, and storing what comes before it costs more than sending the same input plainly. So when the part that changes sits before the breakpoint, nothing is reused, and a breakpoint in the wrong place costs more than none. One placed after the part that stays the same fixes it.
The reused part is always the opening, so what stays the same goes first and what changes goes last. Tool definitions sit at its start, and the reply’s schema is part of it too, so both are kept the same from one request to the next.
Once it’s live, a team can see how much of each request was reused, and move the breakpoint if it’s in the wrong place.
Choose where the reusable part ends. The next request shows what’s reused.
A support assistant’s request
An exampleThis request, written as one message
Where the reusable part ends
Instructions
The same for everyone
Examples
The same for everyone
The customer’s details
Change with each customer
The question
Changes every time
The next request: another customer, a new question
Instructions
{{ caS0 }}
Examples
{{ caS1 }}
The customer’s details
{{ caS2 }}
The question
{{ caS3 }}
{{ caLine }}
A reused opening lets the reply start sooner, and costs less than sending it again.
{{ caSaid }}
Each model change tried on your tests first
OpenAI offers its models as snapshots, each a version locked in so its behavior stays consistent, so a product names the snapshot its tests passed on.
A new model can change more than its answers. Its settings and the way it reuses a request’s opening can change too, as the guides OpenAI publishes for new models show, so each move is read in its guide, run on the test set, then switched.
OpenAI retires older models and APIs with notice, each listed on the deprecations page with a shutdown date and a recommended replacement. The Assistants API is one: it was retired, with a guide for moving to the Responses API.
A product on a model or an API with a shutdown date gets a next step: its replacement tried on the test set, and the move made well before the date.
Start with the request your product sends most
The review covers the models and snapshots in use, and where each stands on the deprecations page; how requests are put together, and what’s reused; how replies are read; the test set, or the cases that could become one; the tools and what each can do; projects, keys, roles and spend limits; the data settings; errors, refusals and rate limits; any legacy API still in use; and where the cost of a request can come down.
The first changes come in the order we’d make them, with a test set to start from.
What you receive is a written review and a proposal for that first step.
Questions worth asking
What does the API keep of what we send?
Data sent to the API isn’t used to train OpenAI models unless you choose to share it. What’s kept is set out on the data controls page OpenAI publishes: logs for abuse monitoring, kept for a limited time, and what some features store to do their job, which a setting can turn off for replies. Some customers can ask for options that keep their content out of those logs, or set the region where it’s stored. We set what your product sends and stores, and write it down.
Which model should we use?
The one that passes your tests at a speed and cost that suit the feature. We set the bar with a more capable model, then try smaller ones against the same tests, as OpenAI suggests, and keep the smallest that still passes.
How long can we stay on the model we tested?
Until OpenAI retires that snapshot, on the shutdown date the deprecations page gives, after notice by email and on that page. Preview models can be retired at much shorter notice, so we keep them out of what your product depends on. We run the test set on the replacement well before the date.
Can we change models later?
Yes. We keep the calls to the model in one part of your code, and write the tests around what the feature must do rather than one model’s wording, so a change of model is a change we can test.
What does it cost to work with you?
It depends on the features you run on the API and the first step you choose. Before any work starts, you get a written proposal with the scope, the price or rate, and how you pay.
Can we hire developers for our own team?
Yes, through a dedicated team: Webair developers who stay with your product over time and work beside your own people.
OpenAI is a trademark of OpenAI. Webair is independent of OpenAI, and isn’t sponsored by, endorsed by or affiliated with it.
Let’s build it better
Tell us which request your product sends most and how its replies are read, and we’ll suggest where to begin, in a short call.
Thanks, we’ll be in touch soon.
{{ ctaStatus }}