Production is the hard part.

LynchPine is a software engineering studio in Colombo. We build web platforms, mobile apps, enterprise and supply chain systems, and the AI layers on top of them, then prove each one works before you depend on it.

Projects fail at the joins

A demo needs one good answer. A production system needs the ten thousandth, on the day the warehouse is behind, from someone who filled the form in wrong. The engineering between those two points is where projects stall: where the data comes from, what the system is allowed to touch, what happens when a run fails, and how you know six months later that it still works.

Those are the joins. They rarely show up in a demo, and they are most of the work.

agent playground

Pick a request below. It runs here.

A support system, running. Each request wakes the agents it needs, touches only what it is allowed to touch, and writes down what it did. The third one is refused.

Task: What are our termination rights on the supplier agreement?

run log

  1. Pick a request above. The run is drawn on the left and written here as it happens.

Take the queue yourself Ninety seconds, four agents, one budget.

What a system we build looks like

Five stages, and a loop. The last one feeds the second, which is the difference between a system that degrades quietly and one that gets better on purpose.

  1. sources

    Your data, not the internet's

    Contracts, tickets, SOPs, the spreadsheet one person maintains. We map it before deciding what a model may see.

  2. retrieval

    Retrieval that cites its source

    Hybrid keyword and vector search with reranking, tuned on your questions instead of a public benchmark.

  3. orchestration

    The part that holds

    Routing, tool access, shared state, handoffs. Where most AI projects quietly come apart.

  4. agents

    Agents with a job description

    Scoped and permissioned, so approving one is a decision someone can actually make.

  5. evaluation

    Proof it still works

    A test set from real queries, run on every change, then fed back so the system improves on purpose.

How it finds the right paragraph

Ask a question of a thousand documents and this is what happens. Your material is placed by meaning rather than by folder; the question lands in that space, and the passages nearest it come back, each one still carrying the document it came from. That last part is why an answer can be checked.

retrieval

Keep scrolling to run the search.

  • a chunk of your material
  • how far the search reached
  • what it returned

You be the retrieval step

Here is a question and six passages from a fictional company's documents. Choose up to three for the model to read, then see what it answers. The model is the same every time. Only what you hand it changes.

The questionWhat is the refund window for enterprise customers?

Passages to hand the model0 of 3 chosen

Where we differ

01 / 03

Most of what gets called AI should be an if-statement

A model is a poor substitute for deterministic logic and roughly a thousand times the price. We put one in the path only where the work genuinely calls for judgement. If your problem is really a rules engine, we will say so, and the bill will be smaller for it.

02 / 03

A demo is not evidence

Anything can be made to work once, on a question the vendor picked. We would rather build an evaluation set from your own queries first and show you how the system scores against it. That number is what you can take to a board.

03 / 03

Nobody should marry a model provider

The frontier moves every few months. We put the model behind an interface, so switching one out is a config change and a couple of eval runs. When a provider raises prices or retires the version you depend on, you get to decide what happens next, on your own timetable.

The demo always wins

Two lines, eight builds. One is the query chosen for the demo. The other is a held-out set of real questions. Only one of them is evidence.

  • The query picked for the demo
  • A held-out set of your questions
Score against each source, by build. Illustrative figures.
BuildThe query picked for the demoA held-out set of your questions
0196%47%
0297%55%
0396%58%
0498%69%
0597%74%
0698%79%
0798%84%
0899%86%

IllustrativeThe shape is what matters: a cherry-picked query is at the top from the first build and stays there, so it can tell you nothing about whether the system improved. The line that can is the one that does not reach it.

What a decision costs

Per thousand decisions, at the point in the path where the choice is actually made.

USD per 1,000 decisions

  1. A branch in code

    0.002

    Deterministic, testable, and the same answer every time.

  2. A small model

    0.15

    Worth it where the input is genuinely unstructured.

  3. A frontier model

    2.00

    Worth it where the work genuinely calls for judgement.

IllustrativeRounded hard on purpose: the argument is the order of magnitude, not the third significant figure. Linear scale, so the first bar is a hairline, which is the point of it. Published rates move every few months; the ratio between a branch and a model call has not.

Where the work goes

Based in Colombo, working with clients in Australia, Canada, India, Norway, Sri Lanka and the United Kingdom. Most of it is remote, and the timezone question is usually the real one, so the offsets are on the map.

Australia
UTC +10:00
Canada
UTC -05:00
India
UTC +05:30
Norway
UTC +01:00
Sri Lanka
UTC +05:30
United Kingdom
UTC +00:00

What happens after you email us

Four phases, whatever the work is. The point of running it this way is to force the decisions into the open early, because the ones nobody makes are the ones an AI tool will quietly make for you, in code, where they are expensive to find.

  1. 01

    Clarify

    Week 1

    We find the decisions nobody has made yet, the ones an AI tool would otherwise make for you, silently, in code. You get a written scope and a fixed price before anything is built.

  2. 02

    Plan

    Weeks 2-3

    Architecture, data flow, agent boundaries, and what counts as working. All of it agreed while it is still cheap to argue about, and written down so nobody relitigates it in week six.

  3. 03

    Build and verify

    Weeks 3-7

    Small changes, each one run against the evaluation set. You get a live environment in the first week and watch it fill in, so nothing arrives as a surprise at handover.

  4. 04

    Learn and adjust

    Week 8 onward

    Real use produces cases the plan missed. Those become new tests, the system improves against them, and the loop keeps running after handover, with your team or with ours.

The record

20+
projects delivered
5+
industries served
6-8
weeks, typical build

What you can hold us to

Evaluation before opinion
Every AI system we ship has a test set drawn from your real queries and a score you can track over time. When we claim something got better, the number comes with it.
You own all of it
Source code, prompts, evaluation sets, infrastructure and accounts transfer to you on final payment. Nothing stays licensed from us.
No model lock-in
The model sits behind an interface. Swapping it is a config change and an eval run, so you are never stuck with a provider because leaving would cost too much.
We will talk you out of it
If your problem is better solved by a form, a query or a rule, we will say so before you have paid for a model to do it worse.
Fixed scope, fixed price
You approve a written scope and a number before work starts. Changes get quoted, not absorbed silently and billed later.
Built to be handed over
Every project ships with documentation and a training session. If you replace us next year, the next team can read what we left.

Tell us what is not working yet

Send a paragraph about the problem. We reply within two working days with questions, a rough shape, and an honest answer on whether we are the right people for it.