Pattern 01
Knowledge assistant over internal documents
A permission-aware interface over policies, contracts and manuals. Users only see answers drawn from documents they may read.
02 · Custom AI Applications
Applications built around your workflow, with AI doing the part of the job it is genuinely better at, and an interface people can use, trust and correct.
Custom software is worth building when the workflow is genuinely yours. If an existing product already does 95 percent of the job, we will say so, and build only the integration that closes the gap.
Illustrative application · open a document
It shows what the model produced, where it came from, and lets a person change it. Try it: nothing is recorded until you confirm.
PDF attachment, 2 pages
Model
Read the document
Your systems
Matched your records
Application logic
Checked your rules
Interface
Showed it to a person
Written
Waits for a person
Every edit a user makes is captured. That record becomes the evaluation set, which is why the review screen matters more than the prompt.
When the system should act without waiting for a person, the question becomes what it may do alone. That is an agent, and the two compose well.
A custom AI application is ordinary production software: authentication, data model, permissions, interface, deployment. Inside it sits model-driven capability at the steps that earn it. Drafting, extracting, ranking, summarising, matching, classifying: work a person would otherwise do slowly and inconsistently.
What separates this from a chat window bolted onto an existing product is the interface. When a model contributes to a decision, the screen has to show what it produced, where that came from, and how a person changes it. That is an interface design problem at least as much as a model problem.
Access, rules, integrations and an audit trail are what make a model's output something a business can use.
A process that matters, held together by files, inboxes and habit. It works until the person who understands it is away, and it never produces data anyone can analyse.
The remaining 30 percent is the part specific to how you operate, and it is the part being handled manually, in parallel, forever.
Something impressive was built, then stalled on permissions, data access, auditability, or a screen that gives nobody a way to correct it.
Build patterns and capabilities, not client projects.
Pattern 01
A permission-aware interface over policies, contracts and manuals. Users only see answers drawn from documents they may read.
Pattern 02
The operational tool a team currently improvises, rebuilt properly, with model assistance at the slow and repetitive steps.
Pattern 03
A queue, a review screen and an audit trail. The model prepares each item, a person confirms, edits or rejects it, and the edits become the evaluation set.
Pattern 04
Documents in, validated records out, with a review screen for the cases the system flags rather than a silent best guess.
We map the path work takes today, workarounds included, before deciding what software to write. The exceptions are usually where the value is.
Validation, calculation, routing and permissions are code. The model handles the parts that genuinely need language or judgement, which keeps behaviour predictable and cost sane.
Model output arrives as something to confirm, with its source attached, never as settled fact. People trust a system that admits what it is unsure about.
Every edit a user makes is captured. That record becomes the evaluation set and the honest answer to whether this is actually getting better.
It is usually the first question a regulated organisation asks, so it is settled before the build, not during it.
Which region the application runs in, which region the model is called in, and whether those are the same. Providers publish their own regional options and they are not all equivalent.
Which provider receives which fields, and whether anything identifying has to leave your systems at all. Inside the application, authentication and per-record permissions are ordinary software concerns and the model does not get to bypass them: a user sees answers drawn only from documents they could already open.
Retention of prompts and outputs is a provider setting and a contract term, not a default worth inheriting. It gets decided, written down, and reflected in the architecture.
Which records were touched, by which component, under whose credentials. An audit trail is far easier to design in at the start than to reconstruct once somebody asks for it.
We are engineers rather than your legal advisers, and none of this is legal advice. What we do is build to the position your counsel establishes, put the data-handling decisions into the architecture instead of into a policy document nobody opens, and say so when a design choice would make one of your obligations harder to meet.
Custom software is worth building when the workflow is genuinely yours. If an existing product already does 95 percent of the job, we will say so, and build only the integration that closes the gap.
Typed, tested, version controlled, deployed through a pipeline, with environments and rollback. AI inside does not lower that bar.
Where data lives, which provider sees it, what is retained and for how long: settled before the build, written down, reflected in the architecture.
Provider access sits behind one internal boundary, so changing model or vendor is a configuration change and a re-run of the evaluations, not a rewrite.
Documented architecture, runbooks and access. Operate it yourself, have us operate it, or move it to another team.
These applications are built mainly for companies in the United Arab Emirates and Saudi Arabia. Where the fit is right we work with clients in the United States and Europe, and where data may live is settled in the same conversation.
Start a projectThe other two lines
Bring the spreadsheet, the inbox and the person who knows how it really runs. The exceptions in that process are usually the whole specification.