A CI pipeline that fixes its own bugs
AI in your development pipeline.
Claude Code integration, agentic CI, AI-assisted review.
AI and automation
We don’t build language models. There are maybe forty companies on earth that should, and you’re almost certainly not one of them.
What we do is put existing models to work on things that were previously done by hand. That’s a much less exciting sentence and a much more useful one.
Where we come out
Calls we’ve made, and what would make us call each one the other way.
-
Fine-tuning fixes format, not facts.
A model that doesn’t know your business has a retrieval problem, and a fine-tune freezes a snapshot you then maintain. Tune when one narrow task has to run cheaply. Or when prompting keeps missing an output shape.
-
Most of what gets sold as an agent should be a state machine with model calls inside.
Named steps give you retries, logs, a bill you can forecast and cases you can score in CI with promptfoo. A loop that picks its own tools is right when the order of the work really does depend on what it finds.
-
Self-hosting an open-weight model costs more than the API until the GPU is busy.
An H100 rents by the hour whether anyone asks it anything or not, so divide the monthly rental by your tokens a month and compare that with the per-token price. If the data can’t leave the country, vLLM on Llama or Qwen is the only route.
What we build
-
MCP servers.
We’ve wired six MCP servers into production — Jira, Zoho Projects, MongoDB, Firebase, Playwright and Sentry — so agents can read and act on the systems a team already uses instead of a copy of them.
-
RAG over your own documents.
Vector search with cross-encoder reranking, because plain vector search is usually why these projects disappoint. Chunking strategy chosen against your documents rather than a default. $10,000 – $20,000.
-
Agentic workflows.
Multi-step agents that handle a process end to end rather than answering one question.
-
AI in your development pipeline.
Claude Code integration, agentic CI, AI-assisted review.
-
Computer vision.
YOLO, MediaPipe, SORT tracking, real time.
-
Plain automation.
Scripts, APIs, webhooks. Sometimes the answer isn’t AI at all, and we’ll say so.
The stack
Models and routing
- Claude
- OpenAI
- Bedrock
- LiteLLM
- vLLM
Agents and retrieval
- MCP
- LangChain
- vector databases
- BM25
- Hugging Face Transformers
Observability
- Langfuse
- promptfoo
Vision
- YOLO
- MediaPipe
- SORT
- OpenCV
- TensorFlow
Machine learning and code
- scikit-learn
- Python
- GitHub Actions
Does this need a model at all?
Four things people ask us for, and what we’d actually build.
-
A report somebody rebuilds by hand every Monday
That’s a database query, a scheduled job and an email. No model, no retrieval, nothing to evaluate. We’ll build that instead, at the automation band — $3,000 to $8,000 — against $10,000 to $20,000 for the chatbot.
-
Sorting things by rules you already have
If the rules are written down and your people agree on them, that’s a rules engine. You can read it, test it and change it without touching a prompt. When the rules change, your operations lead edits a table instead of booking us.
-
Nobody can find anything in ten years of documents
This one does want retrieval. We try a BM25 keyword index over the same documents first. If it answers 40 of your 50 test questions, the model is only writing the sentence, and the budget moves to permissions and chunking.
-
Free text in, structured fields out
Invoices, emails, forms, scanned statements. Models are good at this and scripts are bad at it. Each field gets a confidence score and a validation rule: totals have to add up, dates have to be real. Under the line you set, it goes to a review queue.
How we know it works
The measurements we agree with you while we’re scoping the work, because a demo proves nothing.
-
The test set comes before the build
We ask for fifty to two hundred real questions, with the answers your people would give. They come out of your tickets, emails and search logs. If that set can’t be assembled, we say so before you spend anything.
-
Retrieval is measured on its own
Before the model writes a word we check whether the right passage was fetched at all: how often it lands in the top ten — recall@10 — and how much the cross-encoder reranker improves that. Both numbers go in the handover document.
-
Every prompt change gets a regression run
The evaluation set runs in CI on each prompt edit, model upgrade and chunking change, with promptfoo on GitHub Actions. A change that fixes one case and breaks four shows up in the pull request, not in production.
-
Every production call is traced
Langfuse keeps the prompt, the retrieved context, the model, the tokens and the output for each call. When somebody says it gave a bad answer on Tuesday, we open that call and reproduce it rather than guess.
-
Ninety in a hundred, or it doesn’t ship
The default line is 90 correct in a hundred of your test questions, and no more than 5 confident answers where it should have declined. You can set it higher. If the build misses the line, it doesn’t go live.
What we switch off
The limits we build in on purpose, which make for a dull demo and a system you can live with.
-
Agents read freely, write under review
Anything that leaves the building or can’t be undone stops at a person: an email to a customer, a refund, a delete, a merge to main. The agent prepares the action and somebody approves it.
-
Hard spend caps, not alerts
Budgets per user, per day and per workflow, set at the gateway with LiteLLM. When a cap is hit the call fails and somebody is told. An alert that arrives after a looping agent has billed you is not a control.
-
Refusing beats guessing
When retrieval comes back weak, or the answer has no source to cite, the system says it doesn’t know. A confident wrong answer costs more to undo than a question that gets escalated.
-
What we log, and what we don’t
Prompts, retrieved document ids, model, latency and cost, kept for a window you set. Keys, card numbers and email addresses are matched and removed. Personal data someone types in their own words can slip through, so traces inherit the document permissions.
Your data
Answered with the mechanism, because a reassurance isn’t something you can check.
-
Whether your prompts train anyone’s model
The Anthropic and OpenAI API tiers we build on don’t train on your data. That’s their terms rather than our promise, so we show you the clause and the account setting, and ask for zero data retention where it’s offered.
-
Where the data physically goes
You pick the account and the region. Bedrock, or a regional Azure OpenAI deployment rather than a global one, keeps inference in the geography you name. We put the deployment type in writing, because a global one doesn’t.
-
Who opens it, and where they sit
Our engineers are in Kathmandu. Your data is read from Nepal, through credentials you grant and can revoke, and we name every person with access in the contract. We keep no copy of your documents.
-
Documents and embeddings at the end
An embedding is your document in another form, so we treat it as the document. The index sits in your account from the first day. At handover you get a written list of every store and key, and our access is revoked.
-
When self-hosting is the right answer
When the data legally can’t leave a country, run Llama, Qwen or Mistral on vLLM in your own network. The GPU bills all month whether anyone asks a question or not, and the open-weight model is a step behind on reasoning. You’re buying a location, not quality.
What it costs to run
The build is a one-off. The bill that follows it isn’t, and most quotes say nothing about it.
-
Tokens, embeddings, vector store, tracing
Tokens in and out, where the retrieved context is the largest share once you fetch more than a page or two per answer. Embedding the documents, and re-embedding them when they change. Most of it goes to the provider, not to us.
-
The sum, run on your numbers
Three thousand tokens of context in and four hundred out is about a cent a call on Claude Sonnet 5.5 at today’s list price. Two thousand calls a month is roughly $20; twenty thousand is roughly $200. We run it on your traffic first.
-
Context, not headcount
More documents, longer context, chat history replayed on every turn, and agents that retry. The bill usually climbs because each call is carrying more context, not because more people started using it.
-
Cheap calls stay cheap
Prompt caching on the system prompt and the retrieved context, which the provider bills at a fraction. A response cache keyed on the question, so the hundredth person asking about the refund policy costs nothing. Haiku for routing, Sonnet where it earns it.
How engagements work
-
An engineer on your team
You need people.
Who it suits — you have the roadmap and the reviews, you’re short the person.
What you manage — the work, day to day, in your tools.
What it costs — from $5,000/month for a senior AI engineer, 160 hours — about $31 an hour. Minimum 20 hours.
How it starts — a call, then one to two weeks to ramp.
-
A product built
You need a thing built.
Who it suits — you want the problem gone, not managed.
What you manage — the outcome. We run the build.
What it costs — MCP server setup from $5,000. Agentic workflow $10,000–$20,000. 30% up front, 40% at an agreed midpoint, 30% on delivery.
How it starts — a scoping call, then a written scope and fixed price within a few days.
-
A decision made
You need someone to tell you what to do.
Who it suits — you’re about to make an expensive decision and want someone with no stake in it to look first.
What you manage — everything. We don’t implement.
What it costs — architecture review from $3,000. Fractional technical lead from $2,500/month.
How it starts — a call and a look at what exists.
What this usually costs
An MCP server setup, $5,000 to $15,000. A RAG chatbot connected to your data, $10,000 to $20,000. An agentic workflow, $10,000 to $20,000. Computer vision, $10,000 to $25,000. Straightforward process automation, $3,000 to $8,000. A senior AI engineer embedded in your team is from $5,000/month at 160 hours.
Every project gets a real quote after a scoping call. These are the ranges so you know whether to bother having one.
Why it costs what it costs
The engineer is senior and writes the code. There’s no junior behind the invoice and no account manager on top of it.
The work happens in Kathmandu, where a senior engineer costs what a senior engineer costs there.
That works out between $25 and $31 an hour at the rates on these pages. For comparison: a senior US contractor runs $100 to $150, and a US agency bills $150 to $225. Same seniority, different address.
The bands above are what a large build costs. Most of what we do is smaller, and we scope to the budget rather than the other way round — tell us what you have and we’ll tell you honestly what fits inside it, or that nothing does.
| Computer vision | $10,000 – $25,000 |
|---|---|
| AI chatbot (RAG, connected to your data) | $10,000 – $20,000 |
| Agentic workflow automation | $10,000 – $20,000 |
| MCP server setup and integration | $5,000 – $15,000 |
| Straightforward process automation | $3,000 – $8,000 |
| Senior AI engineer, embedded, 160 hours | from $5,000/month |
Questions
-
No. We put existing models to work on things that were previously done by hand.
-
We’ve built six MCP servers in production, connecting AI agents to Jira, Zoho Projects, MongoDB, Firebase, Playwright and Sentry, and we wire agents into GitHub and your REST APIs.
-
Then we’ll say so, and we’ll build the simpler thing. A report somebody rebuilds every Monday is a query, a scheduled job and an email — process automation at $3,000 to $8,000, not a chatbot at $10,000 to $20,000.
-
An MCP server setup, $5,000 to $15,000. A RAG chatbot connected to your data, $10,000 to $20,000. An agentic workflow, $10,000 to $20,000.
Tell us what’s broken.
Twenty minutes, no deck. We’ll tell you straight whether this is work we should be doing, and if it isn’t, we usually know who should.
We come back within one business day.