Six AI engines built to survive production
Not demos. Each of these runs against real inventory, real records or real cameras, with the guardrails that a regulated buyer asks about on day one.
The pattern repeats: ground the model in data you own, keep a human on the decisions that matter, and make every answer traceable back to where it came from.
Travel Planner AI Engine
Conversational trip planning that costs out against live inventory.
Travel search is a constraint problem wearing a chat interface. Prices, seats and rooms move while the traveller is still deciding, and a model left to its own recall will happily offer a flight that does not exist.
What we built
Intent extraction turns a free-text brief into structured constraints — dates, budget ceiling, party size, pace, must-sees.
A planner agent fans out to supplier APIs for flights, stays and activities; every option in the answer is one the tools actually returned.
A ranking pass scores candidate itineraries on cost, transit time and how much of the brief they satisfy, then a writer agent renders the day-by-day plan.
Disruption webhooks re-plan only the affected leg, so a delayed flight rewrites one day instead of the whole trip.
- Tool-calling agents
- Constraint ranking
- Supplier APIs
- Vector search
- Response caching
Grounded
in live supplier inventory
- Itineraries are grounded in live supplier inventory rather than model memory.
- Re-planning is incremental — one leg, not a full regeneration.
- Every recommendation carries its supplier, price and the moment it was fetched.
Medical Drug Description & Chat AI Engine
Drug answers that cite the label they came from.
Drug information is the domain where a confident wrong answer does real harm. The engine had to answer in plain language about dosage, interactions and contraindications while making it impossible to pass off a fluent guess as a fact.
What we built
Hybrid retrieval — vector plus lexical — over licensed monographs and approved labels, so exact drug names and dosage strings survive the search.
A re-ranking pass puts the passage that actually answers the question in front of the model.
Generation is citation-enforced: an answer that cannot point at retrieved text is not returned.
Guardrails refuse individualised clinical advice and hand off to a clinician, and every exchange is logged for audit.
- Hybrid RAG
- Re-ranking
- Citation enforcement
- Refusal guardrails
- Audit logging
Cited
every answer traced to source
- Each answer is traceable to the passage and document it came from.
- Questions outside the corpus are refused rather than improvised.
- A complete audit trail of question, retrieved sources and response.
Agentic Project Management System AI Engine
Agents that keep the plan honest between standups.
Delivery data is already in the tracker; nobody has time to read it. The ask was an engine that watches the board the way a good delivery lead does — and that can never quietly rewrite the plan on its own.
What we built
Connectors stream tracker and repository events into a working model of the plan: scope, sequence, owners, dependencies.
A planner agent drafts breakdowns and re-sequencing; a critic agent argues against them before either reaches a human.
Slippage is detected against the baseline, with the evidence attached — the commits, the moved dates, the blocked dependency.
Every write back to the tracker sits behind an approval gate, so the system proposes and a person disposes.
- Planner / critic loop
- Tracker connectors
- Event streaming
- Human-in-the-loop
- Evals
Approval-gated
no silent writes to the tracker
- Proposals arrive with their evidence rather than as an unexplained verdict.
- No silent writes: the tracker only changes when someone approves the change.
- Standup prep is assembled from the board instead of from memory.
Health Consult Prescription AI Engine
From consult audio to a prescription a clinician signs.
Clinicians spend the consult typing instead of listening, and prescribing errors cluster exactly where that attention is split. The engine had to do the paperwork without ever becoming the prescriber.
What we built
Speech-to-text with speaker separation turns the consult into an attributed transcript.
Structured extraction maps the transcript onto the clinical note — history, findings, assessment, plan — with the source utterance kept against each field.
A prescription draft is checked against the formulary, the patient's recorded allergies and known interactions before it is ever shown.
The clinician reviews, edits and signs; nothing reaches the pharmacy without that signature, and the whole chain is retained for audit.
- Speech to text
- Structured extraction
- Interaction checks
- Clinician sign-off
- HIPAA-consistent
Clinician-signed
nothing leaves without review
- The note is drafted from what was said, with each field traceable to its utterance.
- Interaction and allergy checks run before review, not after dispensing.
- Clinician sign-off is a hard gate in the flow, not a convention.
Facial Recognition System AI/ML Engine
Enrolment, liveness and match — at the edge, under consent.
Recognition is the easy part. Doing it at gate speed, refusing a printed photo or a replayed video, and holding biometric data to a standard the privacy office will sign off on is the actual engineering.
What we built
An embedding model turns enrolment images into templates; matching runs against an approximate-nearest-neighbour index so 1:N stays fast as the gallery grows.
Liveness and anti-spoof checks run before matching, so a photo, a mask or a replayed frame fails at the door.
Inference runs on edge hardware — templates and frames stay local, and the network sees a decision rather than a face.
Consent capture, retention windows and per-cohort accuracy testing are part of the pipeline, with drift monitored on live traffic.
- Embedding models
- ANN index
- Liveness detection
- Edge inference
- Drift monitoring
On-device
templates stay at the edge
- Biometric templates stay at the edge rather than accumulating centrally.
- Presentation attacks are rejected before a match is attempted.
- Accuracy is measured per cohort and watched for drift, not assumed from a launch benchmark.
Enterprise LMS AI Engine
Course material that keeps up with the product.
Enterprise training goes stale the week after it ships. Authoring is the bottleneck, and one course for everyone means the expert and the newcomer sit through the same hour.
What we built
Product documentation, release notes and SME material are ingested and indexed as the single source the engine draws from.
Modules and assessments are generated from that corpus, then routed to a subject-matter expert — generation drafts, it never publishes.
Skill-gap mapping sequences a path per learner, so assessment results change what comes next rather than just scoring the past.
xAPI and SCORM-compatible events feed analytics on where learners stall, which is what tells authors the material is wrong.
- RAG over SME content
- Assessment generation
- Adaptive paths
- xAPI / SCORM
- Learning analytics
SME-reviewed
generation drafts, never publishes
- Course material is regenerated from the same corpus the product ships against.
- Nothing publishes without an SME approving it.
- Paths adapt per learner instead of running one fixed sequence.
Bring us the one that keeps slipping.
Every engine above started as a problem someone had already tried to solve twice. Tell us what you are building — a delivery lead replies within one business day, NDA on request.