Custom software
Quoting, scheduling, inventory, dashboards, internal tools: the operations layer, built to fit how your business actually runs instead of forcing your business to fit a product.
Engineering
We build the version that has to survive contact with real work.
The lab tests and advisory decides. Engineering is where something gets built and has to keep working. We build prototypes that settle arguments, production systems that run every day, and the ordinary software around them that makes the whole thing usable.
Prototypes
A prototype is a question, built.
When an idea is uncertain, the cheapest honest move is to build the smallest version that can be tested against real-shaped input. Not a slide, not a mockup, but a working thing with a scoreboard.
What you receive is the prototype, its test results with the failures listed, and a recommendation you can check against the evidence: continue, change approach, or stop. Sometimes the honest result is “stop”, and hearing it at prototype size, before the real money, is the point.
What happens after a prototype works. A working prototype is an argument, not a product. Getting from one to the other is a known road: the error handling nobody demos, the integration with the tools you already run, the review steps where judgment stays human, the monitoring that notices drift before your customers do. That's the production build. Because the prototype defined what “correct” means, the production system inherits its test bench and has to keep passing it.
What we build
The systems themselves.
Some of this is AI. Most of it, honestly, is well-engineered ordinary software, which is usually why it works.
The AI parts
Reading documents, sorting what arrives, drafting replies, routing work, answering questions with the source shown, all built into your systems where they've earned it, with review steps where mistakes are expensive, and built to stop and ask a person instead of guessing.
Integrations
Your website, your books, your calendar, your industry tools, connected so information stops being retyped and starts flowing. Unglamorous, high-payoff work.
Websites & applications
Customer-facing builds: live inventory, search, calculators, applications taken on the site. The public proof of this one is on the work page: live, dated, checkable.
Ongoing care
Shipping is the midpoint.
Systems drift. They get quietly worse at a job they used to do well. Vendors change their connections, document formats mutate, AI models get updated underneath you, and the workflow the software was shaped around evolves. A system nobody is measuring degrades silently, and the AI parts degrade more silently than most.
So the systems we run under care keep getting evaluated the same way the extraction bench in our lab works: a test set with known correct answers keeps running against the live system, failures get read by a person, and improvements ship on evidence. You see what we see, including the numbers that got worse, when they do.
And when something breaks, you are not filing a ticket into a void. The number on this page rings a person who knows your system, and what we found and fixed goes to you in writing.
Have something that needs building, or rescuing?
New build, stalled build, or a prototype that needs to become a product: describe it in a call, and we'll tell you what we'd do first.