Service AI Engineering

Add Claude or OpenAI to your existing app, observably.

We integrate AI into your existing app with prompt caching, structured output, cost dashboards, and fallback wiring. Your team gets a feature that ships, not a science project.

Projects are scope-dependent. Free discovery call.

Why this matters

The first AI integration is easy. The third is where teams stall.

The first feature ships in a sprint. By the third, your codebase has three different retry patterns, two cost dashboards that disagree, and no one knows which prompts are cached. We build an AI layer that scales past the first feature, with the observability and cost controls a real production system needs.

An integration, end to end

Webhook in, structured output back.

One call from your existing app, Claude does the work, response is typed and validated before it touches your code. Below is the shape we drop in. Scroll up and back down to replay.

Integration Layer claude-opus-4-7 · Zod schema · prompt cached
live
You

Summarize this support ticket thread and extract the top-3 intent labels.

claude.messages.create cache:"prompt+system", schema:"TicketSummary" running
summary_chars 187
intents ["refund_request","escalate","feature_ask"]
cache_hit true
cost $0.0021
Integration Layer

Median latency 412ms Cache hit 91% Cost / call $0.0021
  • Typed output Zod + structured schemas · invalid responses fail fast, never silently
  • Prompt caching shipped from day one · cache hit rate and per-call cost visible in your own logs
  • Cost ceiling enforced per-tenant · finance knows the max bill before it arrives

What we build

An AI layer that holds up under real traffic.

Prompt caching, structured output, observability, cost guards, fallback wiring. Every integration ships with the operational pieces a real production system needs.

01

Prompt caching wired by default

System prompts and long context cached on every call. Cache hit rate measured on your real traffic rather than assumed. Repeat context is not paid for twice, which is where most of an unoptimised token bill goes.

Cost per AI call drops from cents to fractions of a cent.

02

Structured output with Zod schemas

AI calls return typed data, not strings to parse. JSON schema enforcement at the model layer. Your downstream code never crashes on a hallucinated key.

Output validation errors fall to near zero.

03

Cost dashboard before launch

Per-feature, per-user, per-tenant token spend tracked in your existing observability stack. Alerts fire before bills surprise you, not after.

No more surprise bills at end of month.

04

Streaming UX that feels native

Server-sent events, partial JSON parsing, optimistic UI. The AI feature feels like part of your app, not a third-party iframe with a spinner.

Perceived latency drops from seconds to milliseconds.

05

Fallback model wiring

Primary model down? We fall back to a secondary model or cached response automatically. SLA holds even when Anthropic, OpenAI, or your inference provider has an outage.

AI features stay up during model provider outages.

06

Observable from the first request

OpenTelemetry traces on every model call. Per-prompt latency, cost, cache utilization, and quality metrics in your existing dashboards. Debug is grep, not vibes.

Mean time to debug a bad output under 10 minutes.

Cached

from the first integration, not bolted on after the first bill arrives

Prompt caching, batching where latency allows, and per-call cost logging so you can see what each feature costs to run.

The observability layer

Every model call traced, every dollar accounted for.

OpenTelemetry traces with cost, latency, cache utilization, and token counts. Per-feature dashboards. Alerts before bills surprise you. Debug is grep, not vibes.

observability/ai-trace.ts ts
    
      
          
          // observability/ai-trace.ts
        
          
          import { trace } from '@opentelemetry/api';
        
          
           
        
          
          export async function tracedCompletion(input: PromptInput) {
        
          
            return trace.getTracer('ai').startActiveSpan('completion', async (span) => {
        
          
              const start = performance.now();
        
          
              try {
        
          
                const response = await client.messages.create(input);
        
          
                span.setAttributes({
        
          
                  'ai.model': input.model,
        
          
                  'ai.input_tokens': response.usage.input_tokens,
        
          
                  'ai.cache_read_tokens': response.usage.cache_read_input_tokens ?? 0,
        
          
                  'ai.output_tokens': response.usage.output_tokens,
        
          
                  'ai.cost_usd': calculateCost(response.usage, input.model),
        
          
                  'ai.latency_ms': performance.now() - start,
        
          
                });
        
          
                return response;
        
          
              } finally {
        
          
                span.end();
        
          
              }
        
          
            });
        
          
          }
        
    
  

Process

How an AI integration runs.

01

Discovery

One to two weeks. We audit your existing app, identify the workflows where AI fits, design the prompt and output contract, and lock the cost ceiling. You approve the spec before any code.

Fixed scope, fixed price.

02

Build

Three to six weeks. The AI layer ships behind a feature flag. Cache, observability, structured output, and cost guards in from commit one. Staging available within seven days.

You can use the feature in week two.

03

Launch + monitor

One to two weeks. Canary rollout, cost and quality dashboards live, on-call coverage during the first 30 days. Handoff docs and team training before we step back.

Your team owns the AI layer at the end.

What it costs

Integration pricing follows what the model needs to see.

Adding a model to one screen and wiring it through an application with your data behind it are the same sentence and very different projects. Here is what moves the number.

What moves the number

  • How much of your data A generic assistant is quick. One that answers from your content needs that content prepared, kept fresh, and scoped so it never shows the wrong user the wrong thing.
  • Where it appears One feature in one place is contained. Threading it through an existing product is a larger piece of work.
  • Cost control Token cost is a running expense, not a build cost. Caching and prompt design are what keep it predictable, and both are cheaper done early.
  • What it must never do Guardrails, refusals and a tone that fits your product. Easy to skip and the first thing a customer notices when it is missing.
  • How you know it works Evaluation against real examples rather than a vibe check, which is what stops quality drifting after launch.

Small, well-defined work is usually better handled as an hourly block than scoped as a project, and we will say so rather than inflate it into one.

Rough idea to delivery

  1. You send the details What you want built, roughly, plus budget range and timing. The form asks for all of it
  2. Within 4 business hours We read it and reply. Nothing is scheduled before we know what it is about
  3. Then the call Free discovery, booked once there is enough on the table to make it worth your hour
  4. Within 48 hours of the call A written fixed-price quote you approve before anything starts
Get an estimate

Quick enquiry

Adding AI to something you already run?

Tell us what the app does and what you want the model to do inside it. If you are worried about cost or accuracy, say which, because they pull in different directions.

Prefer the full form? Start a project

No drip sequences, no marketing list. We reply and that is it.

Common questions

Frequently asked

  1. Which model should we use?

    Depends on the workload. Claude Sonnet 4.5 for reasoning, code, and agentic workflows. Haiku for high-volume classification or extraction. OpenAI for some tool-calling patterns. Open-weight (Llama, Qwen) for data residency or cost ceilings. We pick based on the actual job, not the brand.

  2. How do you keep AI costs predictable?

    Prompt caching, model routing, per-tenant rate limits, hard cost caps per user, and a real cost dashboard before launch. Most of our integrations cost under one cent per user request in production.

  3. What about hallucinations?

    Structured output with schema validation handles most of it. Retrieval grounding for factual responses. A separate validator pass for high-stakes outputs. We agree on a quality bar with you and write the evals to enforce it.

  4. Can you add AI to a Laravel app? WordPress? Astro?

    Yes to all three. We have shipped AI features into Laravel apps, WordPress plugins, Astro frontends, and bare Node services. The AI layer is wire-protocol agnostic.

  5. How do you handle data privacy?

    PII filtering before the model call, configurable data residency (Anthropic regions, OpenAI EU, on-prem inference), no training opt-in by default. We document the data flow and review it with your legal team before launch.

  6. What does it cost?

    Integration work is estimated against scope rather than sold at a list price. Adding a model to a single screen and wiring one through an existing product with your own data behind it are very different projects. The section above sets out what moves the number.

Ready to add AI without the chaos?

Tell us what you want to build.

Discovery call is free. Fixed-price quote within 48 hours. NDA on request.