Your engineers and your agents already know what to build. What stalls the project is what it costs, when it lands, and whether it pays for itself. One command turns a meeting into three documents that answer exactly that, every figure traced to the work it came from rather than to somebody’s afternoon in a spreadsheet.
Functions shipped across the three projects below
Customers served, every one on this same pipeline
Rows migrated with zero reconciliation failures
Meeting to draft requirements, 95% of runs
A credible plan is the easy part now. Turning it into a number somebody can approve is where things stop, because cost, timing and whether it pays for itself are different questions and nobody owns them.
A plan says what to build. Nobody can approve it until it also says what it costs, when it lands, and what it saves or earns. That translation is still done by hand, by whoever happens to be free.
A price with no line of sight to the work underneath it falls over at the first challenge. Six months on, nobody can say why the figure was that figure.
The call, the thread, the doc, the sheet, and the last version of the plan. Each holds a part of the current picture, so every answer is assembled from memory and starts going stale the day it is written.
Change one input and the whole answer moves. With no before-and-after to compare, there is nothing to review, just a fresh opinion that has to be argued from the start.
So we keep one decision model rather than a pile of documents. Requirements, schedule and price are three views of the same package, each traced to its source, and one new input, whether that is another meeting, a revised estimate or a changed rate, moves all three together. See what comes out.
One says what is being built and what nobody has answered yet. One says how long it takes and in what order. One says what it costs and whether it pays for itself. Everything after them is execution.
Sources read, requirements typed and scored, and every gap written down as a question addressed to a named person rather than filled in silently.
The same package rolled up into epics and stories, effort summed from items sized one at a time, and every task placed in a month against real capacity.
The same roadmap costed against a rate card: three plans, what each one defers, and what the thing costs to keep running once it is built.
Seven stages, with a schema gate between every one of them: an automatic check that what one stage hands over is the shape the next stage expects. These are the real agents, the real schemas, and the real events they emit.
The three documents say what to build and what it takes. Working with us is the rest of it: we run these stages against your scope and ship the software and the hardware they describe.
/bot-run stock-alerts --assignee @tanaka --research acknowledged in 2.1sgoogle_doc4 documents matchedgmail_thread2 threads matchedgoogle_meet1 transcript matchedgoogle_sheet3 sheets matchedprivate sourcesredacted from previewA cluster monitor, a supply chain rebuild, and a bot that issues tax documents. Different clients, different stacks, and all three delivered through the pipeline above rather than around it.
A cluster health monitoring programme, shipped as a single Go binary with its frontend embedded. The pipeline wrote it in fragments; the work was making those fragments into an application.
A Sydney parts distributor ran on 1,451 JSP pages and MySQL 4.0, on one PC in the office. We replaced it with something that installs from a single file.
A LINE bot that talks a customer through issuing an invoice or a receipt, renders the PDF, files it to Drive, backs it up to S3, and replies with the link. The back office is the chat window too.
Anyone can point a model at a meeting and get a confident answer back. The interesting engineering is in what stops a plausible-looking wrong one from reaching a contract.
Sixteen JSON schemas sit between the stages, one for every point where a stage hands work to the next, and each describes the exact shape that handover has to take. Work moves on only once it matches, so a bad output fails loudly at the boundary instead of quietly downstream.
Costing happens in one place and the document reads from it. Hours come from work sized one item at a time, cost comes from the rate card, and the two are joined after the fact. A change to how a proposal reads cannot move what it says.
A payback period is computed only from figures you supplied. We will price the build, the run cost and the three-year total on our own, and we will never guess what the thing earns you. A return built on a benefit we invented would be the most dangerous number in the proposal.
Work that was never sized is reported as unknown and any total containing it is labelled a floor rather than an estimate. A missing estimate silently counted as zero is how plans come to promise things nobody costed.
Each extracted requirement links back to the document, thread, or transcript it came from, with a confidence score attached. Months later that map is the only reliable answer to why a thing was built the way it was.
Maintenance is eighteen percent of build cost a year. The confidence band is deliberately asymmetric, because unknowns discovered mid-project add work far more often than they remove it. Both are printed with the figure attached, so you can substitute your own.
Little Lab Rats is an engineering studio that designs and builds custom software and embedded systems. The models are a tool we hold. What you are hiring is the engineers holding them, and when something goes wrong there is a person who owns the stack rather than a prompt to retry.
The work we get called in for is the translation between three languages that rarely meet. What the business needs, so nobody commits to something that can only be delivered at a loss. What it changes for the customer, so the spend has a reason behind it. And reliable execution, so there is a working product at the end to sell. Teams tend to be strong at one of the three and hope the other two follow. We take on all three at once, which is why the plan, the price and the software agree with each other.
There is a reason this is not already how software gets built here. Japan spends around ¥7 trillion a year on IT services, and the firms holding that budget invoice by the month, so halving a delivery halves what they earn from it. We start from the opposite contract. We are paid for what we deliver, which makes every hour the pipeline saves margin for us and time back for you. Same tools, opposite incentive.
We are founded by engineers with experience across a range of industries, alongside Dartmouth College alumni bridging research and industry. More about the team and why we build in Japan.
Bring us a problem, a half-formed idea, or a system that has outlived its stack. We will tell you honestly whether we are the right team for it.