Model routing & selection
Claude, GPT-5, Gemini, Llama and Qwen routed by task, cost and latency — with fallback when a provider is down and version-pinning on critical paths.
Development · AI
We build production AI.
Production AI built to survive contact with real users, not stay a notebook demo. Agents, RAG, copilots, automation — shipped with evaluation, observability and cost control from day one.
Corum8 builds production AI systems — agents, retrieval-augmented generation (RAG), domain-specific copilots, automation pipelines and ML workflows. The work spans model routing, context engineering, evaluation harnesses, observability, cost controls and the integration surfaces that put AI inside real workflows rather than leaving it as a demo.
What's included
Everything under “AI development” that we actually run
Context engineering & RAG
Retrieval quality is the product. Chunking, re-ranking and query rewriting evaluated independently from generation — not fixed with a better prompt.
Agents & tool use
Function-calling with strict schemas, explicit state tracking, retry logic and bounded autonomy — hard caps on tool calls, cost and recursion depth.
Evaluation harnesses
Unit-level, golden-set and production-drift tiers. No model upgrade ships without a golden-set re-run first.
Observability & cost control
Every inference logged with prompt, completion, tokens and latency. Per-feature cost dashboards catch the $50K surprise before it happens.
Data privacy & provider posture
On-prem or sovereign-cloud inference for sensitive data, zero-retention agreements elsewhere — the architecture maps to sensitivity, not preference.
Integration surfaces
Slack, Salesforce, Notion, your product UI, your backend — AI is only as good as the surface it lives inside.
Specialist ML
Latency-critical classification, edge inference and anomaly detection where a foundation model is the wrong tool for the job.
Is this you?
Signals you need production AI — not another prototype
You don't need all of them. One is usually enough to justify the call.
Your prototype is stuck in a notebook
It works in a demo, but nobody's brave enough to put it in front of real customers without evals to back it up.
Model spend is out of control
You're paying real money in token costs each month and nobody can tell you which feature drives most of it.
Quality is drifting and you can't prove it
Your AI feature has felt worse for months, but without an eval harness you can't point to why.
Procurement flagged your data architecture
Legal or procurement said sending proprietary data to a third-party provider is unacceptable — you need a different architecture.
One agent works, five more are queued
The team wants to replicate what worked, but every new agent currently needs weeks of bespoke engineering.
Legal wants verifiable behavior, not 'trust us'
You're launching AI where a wrong answer has real consequences and you need an evaluation story you can defend, not a demo.
Sectors
Where we ship AI
The risk profile differs, the engineering discipline doesn't.
Enterprise Ops Automation
Cross-tool agents that run real workflows across Slack, Salesforce and internal APIs.
Finance & Institutional AI
In-region inference and fully traceable outputs for banks, insurers and payment providers.
Developer & Infra Tooling
Copilots embedded in engineering workflows — code review, incident triage, deploy gating.
Document & KYC Document Processing
OCR plus multi-pass reasoning over dense document sets.
Consumer Product Features
AI features users now expect as a baseline — recommendation, summarization, search.
Trading & Market Intelligence
Signal extraction, sentiment models and anomaly detection over market and on-chain data.
PropTech & Real Estate Analytics
Document extraction and valuation-support models over property and lease data.
On-Chain & Web3-Native Agents
Agents that read chain state and execute bounded, auditable on-chain actions.
Process
How an AI build runs, in practice
- 01
Define the eval
The golden dataset and acceptance threshold get written before the prompt — everything after this is guesswork without it.
- 02
Build & route
Model routing, retrieval or agent orchestration, and the integration surface, engineered against the eval set.
- 03
Ship behind a flag
Production behind a feature flag, A/B tested against the existing flow so quality and cost are measurable from day one.
- 04
Monitor & re-evaluate
Cost dashboards, drift monitoring and a quarterly model-upgrade review — production AI is a continuous product.
Case studies
AI work we've shipped
Enterprise agent cost and dense document review, each engineered around the evaluation harness that made the result measurable.
~70% per-user cost reduction on an agent platform
A Series A enterprise-ops startup had an agent prototype that worked but cost real money per beta user — unsustainable pre-Series-A. Multi-model routing, response caching and bounded autonomy caps, paired with a 300-case golden-set eval harness, cut per-user cost by roughly 70% and the new cost model held up under due diligence.
A multi-pass review loop over dense submission documents
A seed-stage platform processing identity and screening submissions had failed twice at other vendors, both times because single-pass extraction could not handle the document variety. We built an OCR layer paired with multi-model reasoning and an agentic multi-pass review loop, measured against the team's own golden dataset so accuracy changes were visible rather than asserted.
40+ AI systems in production
8 Frontier model providers integrated
200M+ Inferences served monthly
Zero Runaway-cost incidents on our builds
Why Corum8
Why teams building AI work with us
Shipping LLM systems since GPT-3.5
Through the Claude 2 breakthrough into the frontier-reasoning era of GPT-5 and Claude 4.
Built for the failure modes, not the demo
Our discipline comes from watching teams hit the same eval, cost and observability problems repeatedly.
One team, one architecture
Model routing, RAG, agent orchestration, evaluation, observability and integration under one roof — no handoffs.
Evals before prompts, always
The golden dataset and acceptance threshold are the first deliverable, not an afterthought bolted on post-launch.
Cost attribution from day one
Per-feature cost dashboards ship with the system — not added after the first surprise invoice.
Positioning work included
How to describe AI honestly to users and procurement — engineering and trust-building together.
What drives scope
What drives scope and budget on an AI build
These decisions shape cost and timeline in the first scoping weeks, well before any engineering starts.
Model sovereignty
Third-party API vs private cloud inference vs fully on-prem — each layer adds real engineering and operational overhead.
Latency requirements
A batch pipeline tolerates seconds; a chat copilot needs sub-second responsiveness; real-time scoring needs tens of milliseconds.
Data integration depth
RAG over public documents is light. RAG over ten internal SaaS tools is an integration project with AI on top.
Evaluation rigor
Vibes-based quality is cheap. Golden-set evals with CI/CD for prompts are a system of their own — but you fly blind without one.
Autonomy level
An AI that suggests is simpler than an AI that acts. Agents with real side effects need stronger evals and rollback logic.
Scale target
An internal tool for 20 people is a different build from a consumer feature at 500K users — caching and compute scale with volume.
FAQ
Questions worth a direct answer
-
AI development in 2026 is mostly systems engineering around foundation models — not training models from scratch. Providers like OpenAI, Anthropic, Google, Meta and Mistral solved the core intelligence problem. The engineering work has moved to model routing, retrieval pipelines, agent orchestration, evaluation harnesses, observability, cost control and the integration surfaces that put AI inside real workflows.
-
Cost is driven by model sovereignty, latency requirements, data integration depth, evaluation rigor, autonomy level and scale target — model API costs are usually a minor line item compared to engineering. A third-party API RAG system over public docs is light; a self-hosted multi-agent system over integrated enterprise data with strict access controls is an order of magnitude heavier.
-
Usually RAG and better prompting solve most problems. Agents matter when a task can't be collapsed into a single prompt. Fine-tuning is rarely the right answer for product behavior and more often the right answer for style or format. Most teams over-index on fine-tuning because it feels serious — a well-built RAG system with good evals and the right model usually outperforms it.
-
Model routing, a context or RAG pipeline, agent orchestration where the task demands it, an evaluation harness with golden datasets, observability, data governance and the integration surfaces. CI/CD for prompts, A/B testing against existing flows and post-launch quality monitoring ship as standard. Underlying business data quality and organizational change management sit outside the engineering scope.
-
It depends on task type and constraints, not preference. Complex multi-step reasoning favors Claude Opus-class models; cheap classification and routing favor mini-class models; long-context summarization favors Gemini Flash-class models; Llama or Qwen when data sovereignty or cost dominate. Most production systems route between at least two providers for reliability and cost.
-
Through architectural choices, not policy documents. For sensitive data, we deploy open-source models on customer infrastructure or use sovereign-cloud endpoints with in-region routing. For less sensitive flows, we negotiate zero-retention agreements with API providers. Prompt redaction and field-level encryption happen at the data-access layer, not as an afterthought.
-
Through an evaluation harness built before the prompt, plus ongoing production monitoring. Unit-level tests cover deterministic behavior, golden-dataset tests cover open-ended quality against a curated reference set, and production drift monitoring covers live quality signals. Every prompt change and every model upgrade re-runs against the golden set before it ships.
-
AI earns its place wherever the task genuinely needs open-ended reasoning. Summarising messy documents, answering questions from unstructured sources, handling input a form could never anticipate — that is where it shines and where users feel the difference immediately. Where a rule or a classifier already does the job perfectly, we will tell you and save you the model cost. We usually start by mapping which parts of a workflow are genuinely open-ended and which are not, then build the model into exactly those places.