Custom Software
AI that helps. Code that decides.
We build custom software with your team that uses AI for what it is genuinely good at: reading, interpreting, classifying and drafting. Deterministic code stays at the wheel for every decision, calculation and action. That makes it safer, auditable and far cheaper to run.
- Built with your developers
- Deterministic core
- Predictable AI costs
AI in the driver's seat
- Same input, different result on every run
- One clever prompt away from an action nobody intended
- Token bills that grow with every retry and loop
- Impossible to unit test, hard to audit, hard to explain
- An impressive demo that behaves differently in production
Code at the wheel
- Business rules, money, permissions and actions live in tested code
- AI handles the fuzzy parts: documents, emails, free text, classification
- Every AI output is checked against a strict format before code uses it
- Model calls only where they add value, so costs are easy to forecast
- Unsure or unavailable model? The work goes to a person, not a guess
The pattern behind everything we build
The AI is a component with one narrow job. It never holds the keys.
- Deterministic code
- AI, with a narrow job
- People
Code
Receive and validate
Input arrives through your systems. Code checks who sent it, what type it is and whether it is within limits, before any AI sees it.
AI
Interpret the messy part
The model reads the unstructured part. It extracts fields, picks a category, summarises or drafts, and returns only structured data in an agreed format.
Code
Verify
Code validates the output against the format, your business rules and your own records. Low confidence or a failed check sends the case to a person.
Code
Decide and act
Tested rules make the decision and perform the action. Anything irreversible needs a rule that allows it, or a human approval.
Code
Record everything
Input, model, prompt version, output and final decision are logged together. Any outcome can be explained later to a customer, an auditor or yourself.
Why code stays at the wheel
Three reasons we won't compromise on
Safety
A language model can be talked into things. Code can’t. Anything that moves money, changes permissions, deletes data or contacts a customer goes through rules you can read, test and review.
Cost
Every model call costs money and time. We use AI only on the steps that need judgement on messy input, cache what repeats and use small models where they are enough. The rest runs at the cost of ordinary code.
Reliability and audit
Same input, same decision. Every AI suggestion is stored with its model and prompt version, and every AI step has its own test set, so behaviour can be checked before each release.
What we build with this pattern
A few examples. The common thread: AI reads, code decides
Document intake
Invoices, orders, contracts and forms. AI extracts the fields, code validates them against your ERP or database and posts them. Mismatches go to a review queue.
Inbox and ticket triage
AI classifies incoming messages and drafts replies. Code routes them by your rules, enforces deadlines and keeps a human approval on anything sent to a customer.
Internal knowledge assistants
Answers from your documents and wikis, filtered by what each person is allowed to see. Every answer links to the sources it used.
Data cleanup and migration
AI proposes mappings for messy legacy data. Code applies them, reconciles totals and flags every record that doesn’t add up.
Reporting assistants
Plain-language questions turned into requests against approved metrics, never raw SQL. Our private AI platform is designed exactly this way.
Operations automation
Rule-driven monitoring and follow-up, with AI used only to label free-text messages. See our operations autopilot.
How we work with your team
We build alongside your developers, in your repository, on your stack
Map the process
We walk through the workflow with the people who run it and mark the steps that genuinely need AI. Usually that's far fewer than expected, which is good news for your budget.
Build the deterministic core first
Data model, business rules, integrations and tests. The software works end to end before any model is involved, with a person handling the fuzzy steps.
Add AI at the edges
Narrow prompts, strict output formats, a test set for each AI step and a cost budget per transaction. Each AI step has to beat the manual baseline before it ships.
Ship and hand over
Your team owns the code, the documentation and the tests. We stay on as a partner for reviews, new features and the next process.
Is this right for you?
A good fit if
- A process eats hours of skilled time on reading, sorting or re-typing information
- Mistakes are expensive, so you need predictable behaviour and an audit trail
- You have developers and want senior help designing and building with them
- You want AI costs you can forecast, not a surprise bill
Probably not a fit if
- You want a fully autonomous AI agent making its own decisions. We'll explain why we don't build that
- An off-the-shelf SaaS tool already solves it. We'll point you to it
- You need a quick prototype for a pitch deck. We build things meant to run in production
Frequently asked questions
Isn't this just an AI agent?
No, and that’s deliberate. An agent lets the model decide what to do next and which tools to call. We build workflows instead. The steps are defined in code, and the model does a narrow job inside one or more of them. For well-defined business processes that is more predictable, cheaper and much easier to test and audit. We use more autonomy only where a simpler design clearly falls short.
Do you replace our developers?
No. We work alongside them, in your repository and on your stack. That means pairing, code reviews and shared design decisions. Your team understands every line by the time we hand over. If you don’t have developers yet, we can build the first version and help you hire the people who will own it.
Which AI models do you use?
Whichever fits the task and your data policy. That can be hosted models from the major providers, or open-weight models on your own servers when data must not leave. We put a thin layer between your code and the model so you can switch providers without rewriting the application, and we test each AI step before it goes live.
What happens when the AI gets it wrong?
The design assumes it sometimes will. Outputs that don’t match the agreed format are rejected. Low-confidence results go to a person. Checks against your own records catch plausible but wrong values. Nothing irreversible happens without a rule that allows it or a human approval. Every decision is logged so mistakes can be traced and the test set improved.
How do you keep AI costs under control?
Code filters the input first, so the model only sees cases that need it. We cache repeated work, use the smallest model that passes the tests and set hard budgets per transaction and per day. Because the AI is a few well-defined steps rather than an open-ended loop, the cost per transaction is known before launch.
Who owns the code?
You do, completely. It lives in your repository with documentation and tests. There’s no proprietary framework or platform fee keeping you tied to us.
Got a process that's too messy for plain code but too important for a chatbot?
That's exactly the gap this approach fills. Walk us through the process and we'll show you which parts AI should handle, which parts code should own and what it would take to build.
Talk about your projectFree 30-minute call · No sales pitch · Honest assessment