01[ SERVICES ]
Eleven ways we put AI to work.
From agents that act, to knowledge systems that cite their sources, to pipelines that turn a script into film. Every service below sets out what we build, what it guards against, what you receive, and where it already runs.
Book a scoping callBuild agents
Systems that act, not just answer.
Build on your knowledge
Your documents and data, made usable.
Build products and stories
Things your customers use and watch.
- 06AI storytelling and film pipelinesScript-to-screen pipelines that hold a generated story together.
- 07Full-scale AI productsWeb and mobile products with AI at the core, from prototype to launch.
- 08Workflow automation and modernisationMulti-step operations automated, and legacy systems brought up to date.
Run it in production
What keeps AI working after launch.
Plan
Break the goal down
Verify
Test against the goal
until
success check
or budget
Act
Call a tool
Observe
Read the result
01 · Build agents
Agentic systems and loops
Agents that plan, act and check their own work across many steps.
Build agents
Systems that act, not just answer. 03 services
Plan
Break the goal down
Verify
Test against the goal
until
success check
or budget
Act
Call a tool
Observe
Read the result
01 · Build agents
Agentic systems and loops
Agents that work through a task the way a careful person would: plan, act, look at the result, check it against the goal, and go again. Built with the brakes as well as the engine, so budgets, stop conditions and a person in the loop come as standard.
What we build
- 01Plan, act and verify loops with an explicit success check
- 02Multi-agent teams with clear roles and hand-offs
- 03Step and cost budgets on every task
- 04Human approval before any irreversible action
Use it for
- Research and analysis
- Back-office operations
- Case and claims handling
- Software and data tasks
You receive
- The agent system, in your repositories
- A loop controller with budgets and stop rules
- A full trace of every step
Designed against
- Loops that never converge and burn budget
- Work marked done without being checked
- Runaway cost across sub-agents
Built with
- Tool calling
- MCP
- Durable workflows
- Tracing
Guardrails · sandbox · scoped credentials · approvals
Context
Retrieval, memory, compaction
Model
Routed, swappable
Tools
MCP servers, APIs, code
Telemetry and evals
Traces, cost per task, regression gates
02 · Build agents
Agent harness engineering
The model is one component. The harness around it decides whether an agent can be trusted in production: which tools it can call, what context it sees, what it remembers, what it is allowed to do, and how it recovers when a step fails.
What we build
- 01A tool layer of typed tools and MCP servers
- 02Context assembly: retrieval, memory and compaction for long tasks
- 03A permission model: sandboxed execution, scoped credentials, approval gates
- 04Recovery: retries, checkpoints and runs that resume after a failure
Use it for
- Taking an agent prototype to production
- Adding agents to existing systems safely
- Replacing brittle prompt chains
You receive
- Harness source code
- Tool and permission specifications
- An eval suite for the agent's real jobs
- An operating runbook
Designed against
- Agents acting on stale or missing context
- Tools with more access than the task needs
- Long runs that fail silently halfway through
- A prompt fix for one task that breaks another
Built with
- Typed tools
- MCP
- Sandboxed execution
- Checkpointing
Listen
Real-time speech
Understand
Intent, not keywords
Act
Book, look up, update
Hand off
To a person, with context
03 · Build agents
Voice AI and calling agents
Voice agents that hold a real conversation. They listen, cope with being interrupted, understand what the caller wants, act on your systems during the call, and hand over to a person when they should, in the caller's language, including Arabic.
What we build
- 01Inbound and outbound calling agents
- 02Real-time speech recognition and natural voices
- 03Actions during the call: bookings, lookups, updates
- 04Warm hand-off to a person, with the full context
Use it for
- Customer support lines
- Appointment scheduling
- Lead qualification
- Payment reminders
You receive
- A voice agent connected to your telephony
- Transcripts and outcomes for every call
- Escalation rules
Designed against
- Agents that talk over the caller
- Context lost when a call is transferred
- Actions taken on a misheard request
Built with
- Speech-to-text
- Text-to-speech
- Telephony
- Tool calling
Where it runs
Nox AIIn build
Agentic calling platform that holds live phone conversations and recovers when interrupted.
Build on your knowledge
Your documents and data, made usable. 02 services
04 · Build on your knowledge
RAG and knowledge systems
Assistants that answer from your documents and data, not the open internet, and show exactly where each answer came from. We engineer the whole path: ingestion, retrieval, ranking, memory and access control.
What we build
- 01Ingestion for PDFs, scans, tables and internal systems
- 02Hybrid retrieval: keyword and vector search, then reranking
- 03Citations that point to the exact passage
- 04Private deployment, where the data never leaves your network
Use it for
- Legal and policy research
- Internal knowledge assistants
- Customer support answers
- Due diligence
You receive
- Ingestion pipeline and index
- Retrieval evals against a labelled question set
- Access rules mapped from your identity system
Designed against
- Confident answers with no source
- Chunking that separates a fact from its context
- Indexes that go stale after documents change
- Sensitive data surfacing for the wrong person
Built with
- Hybrid search
- Reranking
- Vector stores
- Citations
Where it runs
Law Suit GPTCase study
Distributed retrieval across 40,000+ legal judgments, returning the relevant passage in under two seconds.
05 · Build on your knowledge
Document intelligence and decision automation
Most business rules live in documents: policies, contracts, manuals. We extract them into executable logic and structured data, with every rule traceable to the sentence it came from, so decisions can be automated and audited.
What we build
- 01Rule extraction from policy documents
- 02Output as DMN, FICO or Python
- 03Parsing for forms, tables and scanned documents
- 04Traceability from every rule back to its source
Use it for
- Insurance underwriting
- Lending and credit policy
- Compliance checks
- Claims rules
You receive
- An extraction pipeline
- Executable rule sets
- A source-linked audit trail
Designed against
- Rules that drift away from the source policy
- Ambiguous clauses silently guessed
- Extraction nobody can audit
Built with
- DMN
- Drools
- Python
- Document parsing
Where it runs
Build products and stories
Things your customers use and watch. 03 services
06 · Build products and stories
AI storytelling and film pipelines
Generative video has made a single shot easy. A story is still hard: one character, one style and one script held together across every shot. We build the pipelines and pre-production tools that make that possible.
What we build
- 01Script and story engines across Indian languages and dialects
- 02Storyboards and shot lists generated from the script
- 03Character and style references reused in every shot
- 04Generation that routes each shot to the best-suited video model
- 05Review loops where a director approves, rejects or regenerates each shot
Use it for
- Regional-language content
- Brand films and ad pre-production
- Episodic storyboarding
- Pitch visualisation
You receive
- The pipeline and tools, in your environment
- A character and style reference library
- Shot-level provenance for every clip
Designed against
- A character whose face changes between shots
- A style that drifts across a sequence
- Scripts that lose cultural nuance in translation
- Clips nobody can trace back to their inputs
Built with
- Text-to-video
- Image-to-video
- Multilingual models
- Reference libraries
Where we stop: we build the pipeline and the pre-production. The final cut, sound and grade are produced by your studio or our production partners.
Where it runs
07 · Build products and stories
Full-scale AI products
From idea to shipped product: web and mobile apps with AI built into the core, plus the admin, analytics and billing that let them run as a business. Designed, built and handed over so your team can own it.
What we build
- 01Product design and prototypes on your real data
- 02Web and mobile apps with AI built in, not bolted on
- 03Admin, analytics and billing
- 04A codebase your own team can take over
Use it for
- SaaS platforms
- Education
- Careers and recruitment
- Commerce
You receive
- The shipped product and its source code
- A design system
- Launch checklist and runbooks
Designed against
- AI features that demo well and nobody uses
- Prototypes that collapse under real users
Built with
- Next.js
- React
- Python
- Native mobile
Where it runs
Intake
Forms, email, scans
Classify
What is it?
Decide
Agent, or plain rules
Update
Your systems
Exceptions
Only the hard cases reach a person
08 · Build products and stories
Workflow automation and modernisation
Automate the multi-step work that runs your operations: agents where judgement is needed, plain deterministic code where it isn't. And bring legacy systems onto modern ground without stopping the business while it happens.
What we build
- 01Process mapping to decide what should, and shouldn't, be automated
- 02Orchestrated workflows across your existing systems
- 03Document intake for forms, invoices and scans
- 04Exception queues, so people only handle the hard cases
Use it for
- Logistics and dispatch
- Finance operations
- Document-heavy back offices
- Legacy system migration
You receive
- Running workflows with monitoring
- An exception-handling playbook
- Migration plan and cut-over support
Designed against
- Automating a broken process, faster
- Brittle scripts that break on the first unusual input
- Migrations that stop the business while they run
Built with
- Orchestration
- Document intake
- APIs
- Event queues
Where it runs
Navata TransportDelivered
A decade-old Java transport system moved to a modern web application without pausing dispatch.
Run it in production
What keeps AI working after launch. 03 services
Agent
one protocol
CRM
MCP · scoped
ERP
MCP · scoped
Database
MCP · scoped
Documents
MCP · scoped
MCP · scoped
Payments
MCP · scoped
09 · Run it in production
MCP and tool integration
The Model Context Protocol gives agents one standard way to reach tools and data. We turn your internal systems into MCP servers, with least-privilege access and a record of every call, so each new agent reuses the same governed connections.
What we build
- 01MCP servers for internal APIs, databases and SaaS tools
- 02Authentication mapped to your existing identities and roles
- 03Read-only by default, with writes behind approval
- 04An audit log of every call an agent makes
Use it for
- Connecting agents to CRM and ERP
- Internal APIs as agent tools
- Governed data access
You receive
- MCP servers with tests
- A permission matrix
- An audit log pipeline
Designed against
- The same integration rebuilt for every new agent
- Service accounts holding admin rights
- No record of what an agent did, or why
Built with
- MCP
- OAuth and SSO
- Audit logging
Change
Prompt, model or tool
Eval suite
- Golden set
- Model judges
- Latency budget
- Cost budget
Ship
All checks pass
Blocked
Regression found
10 · Run it in production
Evals and observability
If it isn't measured, it isn't finished. Every agent and every prompt ships with an eval suite that runs on each change, and every step in production is traced, so quality, latency and cost are visible before they become problems.
What we build
- 01Golden datasets drawn from your real cases
- 02Graders: exact checks, rubric-scored model judges, human review
- 03Regression gates in CI before any prompt or model change ships
- 04Tracing of every step, tool call and token cost
Use it for
- Before a model upgrade
- Regulated workflows
- Any agent in production
You receive
- An eval suite and datasets, versioned with the code
- CI gate configuration
- Dashboards for quality, latency and cost
Designed against
- A demo that passes and a production system that doesn't
- Model upgrades that change behaviour overnight
- Costs nobody sees until the invoice arrives
Built with
- Golden datasets
- Model judges
- CI gates
- Tracing
Router
cost · latency · task
Small, fast
Routine tasks
Large, reasoning
Hard problems
Self-hosted
Private data
11 · Run it in production
LLMOps and model deployment
Running models in production is its own discipline: routing each task to the right model, versioning prompts, controlling cost and upgrading without regressions. Including open-weight models hosted where your data has to stay.
What we build
- 01Model routing by task, cost and latency
- 02Prompt and model versioning, with rollback
- 03Cost controls: budgets, caching and batching
- 04Self-hosted open-weight models where data cannot leave
Use it for
- Reducing model spend
- Private and on-premise AI
- Products that use several models
You receive
- Gateway and routing configuration
- A versioned prompt registry
- Cost and latency monitoring
Designed against
- The largest model paid for on every task, however small
- Upgrades that change outputs overnight
- Latency spikes with no fallback
Built with
- Model gateway
- Prompt registry
- Caching
- Open-weight models
Built for how AI works in 2026
Six shifts changed what a good AI build looks like. Each one is already inside the services above.
01 · Harness engineering
The model became one component. The harness around it now decides whether an agent is reliable.
Judge a partner on harness design, not on which model they name.
02 · Agentic loops
Agents stopped answering once and started working in loops, for minutes or hours.
Budgets, stop conditions and human checkpoints are requirements now.
03 · Evals
Eval suites replaced demos. Every change is regression-tested before it ships.
Ask to see the eval set before you ask to see the demo.
04 · Model Context Protocol
MCP gave agents one standard way to reach tools and data.
Your systems become reusable servers, with access you can scope and audit.
05 · Context engineering
Retrieval, memory and compaction became the main lever on answer quality.
Quality is an engineering property: measurable, and fixable when it slips.
06 · Video generation
Video models got good at single shots. Holding a story together is still the hard part.
The pipeline around the models matters more than any one model.
How an engagement runs
Honest scoping, real timelines. We hand you a system, not a notebook.
- 01
Scope
We agree what success means before any code: the jobs to be done, the data, the risks, and the eval set that will prove it works.
- Success metric
- Your data
- Risks
- Eval set
Success criteria and eval set
- 02
Prototype
A thin, working slice on your real data, so decisions are made against evidence rather than slides.
Running on your data
A working slice on your data
- 03
Harden
Evals in CI, tracing, security review, cost controls and failure recovery, before real users arrive.
- Accuracy evals···pass
- Latency and cost···pass
- Security review···pass
- Failure recovery···pass
A production-ready system
- 04
Hand over
Code in your repositories, runbooks, the eval suite and training for your team. You own the system.
your-org / repository
src/evals/runbook.mdtrainingYou own the system
Stack and standards
- Models
- Frontier APIs, including OpenAI, Anthropic and Google, and open-weight models self-hosted when data must stay in your network.
- Agents and tools
- MCP servers, typed tool calling, durable workflows with checkpoints.
- Retrieval
- Hybrid keyword and vector search, reranking, passage-level citations.
- Evals and operations
- Golden datasets, rubric-scored judges checked against people, CI regression gates, tracing.
- Applications
- Next.js and React on the web, Python services, native mobile apps.
- Deployment
- Your cloud, a private VPC, or on-premise.
On every engagement
- Your code lives in your repositories.
- Least-privilege access by default.
- Every agent ships with an eval suite.
- In-build work is labelled as in build.
11[ LEGACY ]
Honest scoping. Real timelines.
Cubixso. hands you a system — not a notebook.