Field notes from the build.
Engineering notes, product updates, and the occasional rant. Written by the people shipping it.
Building with the API? Read the API reference. Subscribe via RSS.
The workflow lifecycle behind an AI agent
An agent task is a loop, not one model call. Here is where each stage spends tokens, where failure modes enter, and what to measure to keep the bill predictable.
Read the full post- Developer
The model bill behind AI agent workloads
A chat call makes one model request. An agent makes several. Here is where an agent's model bill actually comes from and what to measure to keep it predictable.
- Developer
Shadow testing a second AI provider without breaking production
Shadow testing sends live requests to a second provider without returning its answers to users. Here is how to compare cost, quality and errors before you switch.
- Developer
The model bill, line by line
A model bill hides three separate charges: cache, input and output. Here is what each one means and a short checklist for moving an existing OpenAI client to WebWright.
- Developer
One key for chat and transcription
If your product turns recordings into summaries, one OpenAI-compatible endpoint can cover both speech to text and the chat model that writes the summary.
- Product
What Is WebWright? The OpenAI-Compatible AI API Platform
WebWright is an AI API platform for the Wren R1 model. It is OpenAI-compatible: change the base URL to https://webwright.ai/v1 and keep your OpenAI SDK for chat and transcription.
- Developer
A Java quickstart for Wren R1
If you already call OpenAI from Java with the official OpenAI Java SDK, point the same client at Wren R1 by setting the base URL to https://webwright.ai/v1 and the model to wren-r1, then keep your existing call sites.
- Developer
A PHP quickstart for Wren R1
If you already call OpenAI from PHP with the community openai-php/client package, point the same client at Wren R1 by setting the base URI to https://webwright.ai/v1 and the model to wren-r1, then keep your existing call sites for chat, streaming, and transcription.
- Developer
A Ruby quickstart for Wren R1
If you already call OpenAI from Ruby with the official openai gem, point the same client at Wren R1 by setting the base URL to https://webwright.ai/v1 and the model to wren-r1, then keep your existing call sites for chat, streaming, and transcription.
- Developer
A Vercel AI SDK quickstart for Wren R1
Point the Vercel AI SDK at Wren R1 by swapping the provider's base URL to https://webwright.ai/v1 and the model to wren-r1, then keep your existing generateText and streamText calls.
- Developer
A Rust quickstart for Wren R1
If you already call OpenAI from Rust with the async-openai crate, point the same client at Wren R1 by setting the base URL to https://webwright.ai/v1 and the model to wren-r1, then keep your existing call sites.
- Developer
Wren quickstarts: point your OpenAI client at Wren R1
Eleven Wren quickstart guides that point an existing OpenAI client at Wren R1 by setting the base URL to https://webwright.ai/v1 and the model to wren-r1, without rewriting your call sites.
- Developer
Use the OpenAI .NET SDK with an OpenAI-compatible endpoint
If you already call OpenAI from C# with the official OpenAI .NET SDK, point the same client at Wren R1 by setting the client endpoint to https://webwright.ai/v1, then keep your existing call sites for chat, streaming, and transcription.
- Developer
Use the OpenAI Go SDK with an OpenAI-compatible endpoint
If you already call OpenAI from Go with the official openai-go SDK, point the same client at Wren R1 by setting the base URL to https://webwright.ai/v1, then keep your existing call sites for chat and transcription.
- Developer
Use Wren R1 with LangChain: point ChatOpenAI at an OpenAI-compatible endpoint
LangChain's OpenAI chat model already accepts a custom base URL, so moving a chain to an OpenAI-compatible provider is a configuration change, not a rewrite. Point ChatOpenAI at Wren R1 with the base URL https://webwright.ai/v1 and the model wren-r1.
- Developer
Use the OpenAI Node client with an OpenAI-compatible endpoint
If you already call OpenAI from Node with the official openai package, point the same client at Wren R1 by setting the base URL to https://webwright.ai/v1, then keep your existing call sites for chat, streaming, and transcription.
- Developer
Use Wren R1 as the model under test in your evaluation framework
If your evaluation framework accepts a custom OpenAI-compatible provider, point it at Wren R1 by setting the base URL to https://webwright.ai/v1 and the model to wren-r1, then run the same suite you run today.
- Developer
Adding a WebWright provider to your OpenAI-compatible gateway or client
Your gateway, proxy or chat client already speaks the OpenAI-compatible format, so WebWright is a provider entry rather than a new code path. Add the base URL, key and model, then confirm it with one chat completion and one transcription.
- Developer
The questions developers ask first when trying a new AI API
Eight questions developers ask in the first hour with a new OpenAI-compatible API, in the order they arrive, each answered in a few sentences and linked to the deep guide that goes further.
- Developer
Handle errors from an OpenAI-compatible API: what to retry, what to fix, and what to tell your users
Read the HTTP status and the machine-readable type in the error body, classify each failure as retryable or terminal, retry only the retryable ones with bounded backoff and jitter, and show the user a message that matches the real cause.
- Developer
Keep your AI API key on the server: a proxy for browser and mobile apps
If your browser or mobile app calls the model directly, the key that pays for it ships inside the client. Move the call behind a server route you control, and make that route the one place to cap spend and rate.
- Developer
Keep a multi-turn conversation on an OpenAI-compatible API
A chat API does not remember your conversation. The client resends the message list every turn, the usage object shows the prompt growing, and three concrete patterns keep it bounded.
- Developer
Test an OpenAI-compatible integration without spending tokens
Split your AI API tests into three layers: fast unit tests against a stub client, one gated smoke test against the live endpoint, and a quality rubric. Only one layer touches the network.
- Developer
Write the AI client once: keep the provider a config value
Switching AI providers is usually a small change to your HTTP calls and a large change to your codebase. One client boundary, with the base URL, key and model from configuration, keeps the provider a value rather than a rewrite.
- Developer
What to log when you run an OpenAI-compatible API in production
Moving to an OpenAI-compatible endpoint is a base URL and a key change. Seeing what your integration does afterwards takes one log line per call, a few alerts, and one cost-per-success metric.
- Developer
OpenAI-compatible migration self-check
A five-check interactive self-check for teams considering a second OpenAI-compatible provider. Answer five questions about your own integration and get a readiness band, all in your browser.
- Developer
How to evaluate an OpenAI-compatible API alternative
Most developers evaluating an OpenAI API alternative already have working code. Four moves that turn a provider demo into a decision with evidence: match the API surface, run one real workload, decide the failure path, and keep the first move small.
- Developer
The AI API migration review checklist
Five review areas a provider demo hides: contract compatibility, request and response shape, cost model, limits and failure behavior, and data handling. Work through them to a go or no-go with evidence.
- Developer
Use WebWright as a hosted provider in Page Assist
Page Assist is a browser extension that puts an AI assistant in your sidebar. Point it at WebWright's OpenAI-compatible API with your own key and complete a first chat with wren-r1.
- Brand
The story behind the WebWright name
WebWright is an AI-powered API platform for developers. The story behind the name, the outcome with Microsoft, and what we build on the OpenAI-compatible API.
- Developer
Choosing your first AI use case
Most teams do not get stuck on calling a model. They get stuck on what to build first. A four-test way to choose a first AI use case that is real, owned, measurable, and small enough to ship in days.
- Developer
Prompt caching on an OpenAI-compatible API: make repeated context cost less
Most chat requests resend the same system prompt or reference block on every call. Prompt caching prices the recurring part below fresh input, and the fix on your side is mostly how you order the prompt.
- Developer
Reading your AI API bill: how to model and reduce cost per request
An inference bill is arithmetic over tokens. Read the usage object, separate input from output, and find the few levers that lower cost per successful outcome.
- Developer
The data-handling review before you send customer data to an AI API
Most teams clear the technical step first, then the security review asks where the prompt goes and who can see it later. An eight-question checklist for any OpenAI-compatible API provider, with WebWright's published answers.
- Developer
Transcribing long audio without losing timestamps
Long recordings are where a transcription pipeline first breaks. Cut the audio into chunks, transcribe each with a timed format, then stitch the timed output back together with the right offsets.
- Developer
Planning for rate limits on an OpenAI-compatible API: 429, Retry-After, and concurrency
Your first request works, then real traffic arrives and the failures change shape. How to read the published rate limit, honor a 429 and Retry-After, and size a worker pool to the plan's concurrency burst.
- Developer
Five things to have ready before you evaluate or migrate an AI API
Most AI API evaluations stall, not fail. Five things to put on one page first: the use case, how you call a model today, the decision owner, the next step, and a rough volume signal.
- Developer
Give your OpenAI-compatible model the live web, without a second vendor
Enable the built-in web_search and web_read tools on a chat completion, streaming included: the working call, the Premium gate, and what a streamed tool answer looks like.
- Developer
Making an OpenAI-compatible API call dependable: timeouts, retries, and a fallback
A copy-pasteable wrapper for a dependable OpenAI-compatible call: an explicit timeout, retries only where they are safe, and a second base URL behind a feature flag.
- Developer
Streaming vs buffered chat completions on an OpenAI-compatible API
Buffered JSON or streamed SSE: how to consume a chat-completions response, a copy-pasteable stream reader, and the three things that break it.
- Developer
Which transcription response format should your pipeline use?
Each transcription response_format returns a different shape for the same audio. Compare json, text, srt, vtt, and verbose_json, then try one on your own file.
- Developer
Whisper-compatible transcription: test accuracy on your own audio
Run one of your own audio files through the OpenAI-compatible transcription endpoint and score it against a transcript you trust.
- Developer
Ten questions to ask an AI API provider before you commit
A reusable procurement checklist for choosing an AI API provider: ten questions, what a good answer looks like, and how to score the answers.
- Developer
Quality, latency, or cost: what to test first on a new AI API
A repeatable 30-minute evaluation plan for any OpenAI-compatible API: drop-in compatibility, quality on your own prompts, and cost and operations.
- Developer
The OpenAI-Compatible Migration Playbook
A working migration path for adding a second OpenAI-compatible provider: the wiring, runnable curl, Python, and Node examples, a cost model you can trust, and an evaluation harness.
- Developer
How WebWright bills transcription, and how to try it
Transcription is billed by audio duration and is included free on the Premium pay-as-you-go tier. Here is how the transcription endpoint works.
- Developer
Use WebWright with Cline and OpenCode
Cline and OpenCode are tested with WebWright's OpenAI-compatible API. Here is the exact configuration for each.
- Developer
Transcribe Then Summarize With One API Key
A two-call workflow: transcribe an audio file, then summarize the transcript, using one API key and base URL.
- Developer
Point your OpenAI-compatible client at Wren R1
Point an OpenAI-compatible client or SDK at the WebWright base URL, choose the wren-r1 model, and call chat completions or transcribe audio.
- Product
Web Search Tools Are Live
Premium callers can use integrated web_search and web_read on chat completions. No Firecrawl or Tavily keys required.
- Launch
WebWright Is Officially Live
WebWright has officially launched. Sign-ups are open, payments are live, and the OpenAI-compatible inference API is ready for production use.
- Announcement
Pre-Launch Event and Official Launch on Monday
WebWright is hosting a pre-launch event throughout the weekend ahead of our official launch on Monday. New users are invited to sign up and test the platform.
- Operations
Awaiting Financial Processor Approval
WebWright is awaiting approval from our financial processor before accepting payments and officially launching. Here is the timeline.