Most of our products did not start as products. They started as a client problem we were paid to solve: a film studio drowning in script coverage, a training firm with no map of its workforce's skills, a triage line that needed to scale without losing clinical rigor. We solve the specific problem, ship it, and watch what happens next.
When the same shape of problem shows up a third time, we stop rebuilding it by hand. We extract the durable core (the analysis engine, the evaluation harness, the voice pipeline) into something multi-tenant, configurable, and sellable on its own. The client engagement funds the R&D; the product captures the recurring value.

An AI platform for analysing scripts and long documents. Run structured analysis modules, refine conversationally, and teach the system your house methodology so its judgment becomes yours.
The hard part: versioned, reproducible analysis pinned to a hash of its inputs, and a golden-corpus evaluation harness so quality is measurable, not a vibe.
An autonomous content fleet: multi-agent pipelines that research, write, illustrate, and publish to a live CMS on a cadence, with semantic deduplication so they don't repeat themselves.
The hard part: agent-to-agent fact-checking and embedding-based dedupe that let the fleet publish directly to a live CMS, unattended, without drifting off-brand.
A speaking-practice app that analyses how you actually sound, not just what you said: filler words, vocal tremor, pacing, hedging.
The hard part: real acoustic analysis via a Praat phonetics sidecar, and best-in-class voice vendors behind swappable interfaces.
A workforce-intelligence platform that interviews your people by AI voice, builds a skills inventory, finds the gaps, and tells you what to train and who to hire.
The hard part: turning a fluid voice interview into normalized, comparable skills data, and grounding recommendations in the customer's own course catalogue.
Analytics for the post-search era: measure whether large language models cite your brand, how, and why.
The hard part: turning 'do LLMs mention us?' into ~14 stable, comparable, formulaic metrics across non-deterministic models.
Turns a long, intimidating form into a natural conversation. Fill it by talking or chatting, with a drag-and-drop builder behind it for whoever designs the form.
The hard part: keeping a free-flowing conversation and a partially-filled structured form in sync, bidirectionally, generated from the form definition rather than hard-coded.
AI-driven crisis-simulation training: a live, branching scenario run by an AI crisis-master that puts a leadership team through a realistic incident.
The hard part: stateful, multi-turn scenario orchestration that escalates believably instead of railroading participants.
A clinical triage assistant: a real-time voice front end talking to a patient, backed by a supervisor LLM that makes the triage decision against an established clinical protocol.
The hard part: separating a fast conversational voice layer from a slower, authoritative supervisor that owns the decision and the record.
RAG over meeting transcripts with cited answers. Ask what was decided and get the passage that proves it. (Name provisional.)
The hard part: faithful retrieval with citations a reader can verify, over messy, unstructured transcript data.
Regulatory-document semantic search and RAG over large, unstructured regulatory corpora.
The hard part: faithful retrieval over long regulatory documents where a wrong or unsourced answer is worse than no answer.
Photo-to-nutrition food AI: point a camera at a meal and get a structured nutrition estimate.
The hard part: turning a single vision input into a defensible structured estimate rather than a confident guess.
Multi-model business-intelligence orchestration: route a question across models and reconcile the answers.
The hard part: deciding when an ensemble actually beats the best single model, and proving it.
Alongside the product lines we ship and maintain a small set of Model Context Protocol (MCP) connectors that let AI assistants read and operate enterprise systems directly. They are plumbing, not headline products. But they are why several lines above can reach into a customer's existing systems without bespoke integration work each time.

Every product on this page traces the same four-stage loop. We do not start with a roadmap and look for buyers; we start with a paying client and a problem worth solving exactly.


MCP-first is a method, not an afterthought. We build the integration once, as a Model Context Protocol connector behind a clean, swappable interface. Any product or agent above can then read and operate a customer's existing systems without bespoke wiring each time. The same abstraction that lets us swap a model also lets us swap the system of record.
Puts an LLM directly on an enterprise analytics warehouse over both stdio and HTTP transports, so an assistant can query governed business data in place, under the warehouse's own access controls.
Reads and operates an open-source ERP over its native RPC layer. It is the plumbing under several CRM, billing, and content-publishing automations, so agents act on the real records rather than a copy.