A real-time, multilingual voice agent rebuilt from the silicon up — matching a commercial platform on speed and beating it decisively on cost. Where the latency hid, why the cheaper GPU won, and the optimizations that cost nothing.
Insurance, healthcare, shipping, heavy industry. You message it. It builds, deploys and keeps the product running on a machine that is yours, with every action confirmed and logged.
About us
We are a small team of software engineers and operators across Athens, London, San Francisco and New York. We came from big tech, from startups that grew faster than their systems, and from fintech, where a bug is a regulatory event. Every one of us has shipped production code and carried the pager for it.
We chose the industries most software companies avoid. Today we work with leading hospitals, clinics, pharmaceutical companies and heavy industry. These are businesses that run on paper, phone calls and twenty-year-old systems, and where the people are brilliant and the tooling is not. We think that gap is one of the biggest opportunities anywhere.
Our belief is simple. AI now makes it possible to give a hospital or a plant the engineering capability of a technology company, without asking them to become one. We build the systems, we deploy them securely, we keep them running, and we measure everything. If it cannot be measured, we do not ship it.
We work at the edge of what the technology can do: our own voice pipelines on our own GPUs, agent runtimes that write and review code, inference tuned until a millisecond and a cent both matter. We invent techniques when the ones available are not good enough, and we write about them on the Engineering page. Sometimes we build things just because they are fun.
Join us
There is a permanently open position for a hard-working engineer and another for an operator. We do not wait for headcount. If you are exceptional, we make room.
You will own real systems in production for real hospitals and factories, work directly with the founders, use the newest hardware and models available, and see your work change how an industry operates. We pay incredibly well, on purpose. We would rather have a few outstanding people than many average ones.
No cover letter. Send us something you built, and what you learned building it, to d@techmellon.com.
Engineering
What we learned building the systems behind the work: voice pipelines, agent engines, the cost of a millisecond. Written by the people who ran them.
A real-time, multilingual voice agent rebuilt from the silicon up — matching a commercial platform on speed and beating it decisively on cost. Where the latency hid, why the cheaper GPU won, and the optimizations that cost nothing.
Inside the engine of an agent-driven voxel simulation: a deterministic two-speed cognition design, a decaying danger field, stigmergic roads, and a self-balancing market — and what 592 simulated days produced.
A voice on a telephone line is a pressure wave, and a pressure wave is impatient. It has to be captured, transcribed, reasoned about, synthesized, and returned — all inside the half-second before the caller notices the silence. Get it right and the machine disappears; the person simply feels heard. Get it three hundred milliseconds wrong and the illusion breaks all at once. Conversation has no graceful degradation. There is presence, or its absence, and nothing in between.
We built one that keeps its presence: multilingual, booking, real-time. The commercial platform it replaces has carried over 100,000 minutes of calls in production — and that bill, the one that grew with every success, is what set the rebuild in motion. The architecture, it turned out, was never the hard part.
The hard part was the money: how much it cost, where the cost was hiding, and what we had to unlearn to bring it down.
The pipeline
Someone calls. A transcriber turns their voice into text. A reasoning engine decides what to say back. A synthesizer says it. Three steps, in series, on a single GPU — and each one spends two currencies at once: time and money.
One turn, measuredwarm · cached
The three engines plus network and tool calls land a typical turn near 800 milliseconds — a clean turn closer to 600, a complex one with several lookups around 1.2 seconds. The best-known platform on the market quotes one and a half to two seconds for the same work. On an average call we are comfortably faster; on a clean one, close to twice as quick. And because the synthesizer streams, the caller hears the first words before the full turn completes.
The speed matters. The cost matters more. A managed platform meters all three engines: a fixed subscription at market rates before a single call connects, then fifty cents to a dollar and a half per conversation on top. That is the bill this rebuild was meant to bring down.
Benchmarked on the rebuilt stack, the all-in cost per call — transcription, reasoning, synthesis, tools, telephony — is a fraction of that: an 85–95% reduction at our production volume.
measured on representative workloads · full cost breakdown published separatelyThe alternative is simpler than it sounds. Run the models yourself, on your own GPUs.
The hardware
We ran the same models, the same weights, the same containers on two very different cards, expecting the faster one to win.
| Measure | H200 (Hopper) | RTX PRO 6000 (Blackwell) |
|---|---|---|
| Memory bandwidth | 4,800 GB/s | ~1,792 GB/s |
| Decoding throughput | 169 tok/s | 202 tok/s · +20% |
| Transcription latency | ~195 ms | ~195 ms · tie |
| Synthesis latency | ~570 ms | ~550 ms · tie |
| Cost per hour | $2.83 | $1.07 · −62% |
By the textbook, the H200 should have won — inference is supposed to be bound by memory bandwidth, and it has nearly three times as much. It lost anyway. Our reasoning engine activates only a fraction of its parameters on any given word, and a single live call is a batch of one; with so little data in flight, raw core speed beats bandwidth, and the newer Blackwell silicon pulls ahead. The H200's enormous bandwidth becomes a ten-lane highway at four in the morning.
The bandwidth never matters because the work never piles up. This is not a defect of the H200 — it is a property of the conversation. It earns its keep the moment you batch; a single-caller turn is the least bandwidth-hungry thing a modern GPU will ever run.
The software
The biggest source of latency wasn't the synthesizer, and it wasn't the transcriber. It was the prompt.
Our agent reasons against a 25,000-character rulebook — referral codes, mappings, escalation rules. In the naive build, the engine re-read the entire thing before producing a single token of every reply. A cold turn took seven seconds: dead on arrival.
Latency, before and aftercost: nothing
We moved the handful of values that change each turn — the timestamp, the call id — to the end of the prompt, leaving the 25,000 characters in front of them byte-for-byte identical. The engine now processes that prefix once and reuses it forever. Cost: nothing. Improvement: eightfold. Then we found the reasoning engine writing its private deliberation into the reply buffer — burning time, sometimes returning nothing at all — and switched it off: warm turns fell from 3.5 seconds to 0.4, a further factor of nearly nine. Eight-bit quantization of the attention cache cut memory fourfold with no audible loss.
Three wins — caching the prefix, silencing the deliberation, quantizing the cache. None needed a faster GPU. None needed a smaller model. None cost a dollar. Each needed only knowing where the time had gone.
The field
The GPU comes from a spot market: a new machine and a new random port on every deploy, and no working SSH. We lost two hours before accepting the obvious — the whole pipeline would bring itself up over HTTP boot scripts, or not at all. The synthesizer's text normalizer, built for a different set of languages, mangled characters outside it, reading some letters aloud by name instead of voicing them; one configuration flag, one afternoon. And two of eighteen tool parameters didn't match the booking webhook — a mismatch that surfaced not as an error but as an infinite conversational loop, the agent apologizing and asking the caller to repeat, forever. We audited every parameter against the live API by hand.
What remains is one command that provisions the GPU, boots the container, compiles the engine for two architectures, downloads the weights, loads three models, uploads a dozen cloned voices, starts the backend and the frontend, and primes the cache — cold, in about eight minutes. One command tears it all down again, because a forgotten GPU bills by the hour until the credit runs dry.
The arithmetic
Start at a single turn. At $1.07 per GPU-hour, about 800 milliseconds per turn, and ten simultaneous callers on one card, the engines cost a rounding error:
| Line item | Cost |
|---|---|
| GPU — all three engines on one card | ~$0.0005 / turn |
| Cloud reasoning fallback · rare hard turns | ~$0.002 / turn |
| Leading managed platform · enterprise base | ~$3,000+ / month |
| Commercial platform · per conversation | ~$0.50–1.50 / call |
| Our benchmarked stack · all-in | under $1.00 / call |
The comparison that matters, though, is monthly and at scale. All-in: GPU, reasoning, telephony.
| Concurrent | Volume / mo | Self-hosted | Cloud · cheapest | Cloud · premium | vs. premium |
|---|---|---|---|---|---|
| 10 | ~20,000 | $1,199 | $1,499 | $2,299 | −48% |
| 20 | ~40,000 | $1,885 | $2,279 | $3,879 | −51% |
| 30 | ~60,000 | $2,571 | $3,265 | $5,665 | −55% |
| 40 | ~80,000 | $3,257 | $4,045 | $7,245 | −55% |
| 50 | ~100,000 | $3,943 | $5,031 | $9,031 | −56% |
The self-hosted engine carries zero per-token cost; the cloud alternatives meter every token, and the premium one — the default most teams reach for — costs thousands more each month. At fifty concurrent callers the saving against it is fifty-six per cent. Against even the cheapest cloud option, owning the GPUs wins at every tier.
The lesson
The intuition that a bigger model is slower and dearer is wrong in at least three ways, and each was worth real money.
Some architectures carry tens of billions of parameters on paper yet fire only a few billion on any given word. You load the weights once; after that the meter runs on what activates, not on what is listed.
A figure of 4,800 GB/s helps only if the work can saturate it, and a single-caller voice turn cannot come close. The specification and the experience are different numbers.
Prefix caching, eightfold. Silencing the model's deliberation, eightfold again. Greedy decoding, fivefold — and no listener could tell. Not one of them needed better hardware.
Before you upgrade the GPU, fix the prompt. Before you fix the prompt, measure the pipeline. Before you measure, build it so measurement is automatic. The work is unglamorous. It is also the only work that moves the numbers.
The trajectory
The comparison holds at today's models and today's prices, and both are in motion. Open models improve and cheapen with every release; our reasoning engine is the sixth-ranked open model on the public leaderboard, level with proprietary systems that bill by the token. The stack keeps its options open — the production engine fits on a consumer card, and a single toggle routes a genuinely hard turn to a larger cloud model on demand. Most calls never ask for it.
The speech models follow the same curve. The synthesizer — an open diffusion model at 48 kHz with zero-shot voice cloning — rivals proprietary text-to-speech in the languages we serve; the transcriber, tuned with domain vocabulary and typo correction, handles the booking flow reliably. Both improve with every open-source release.
Zero dollars per token is not a price a competitor can undercut.
the long gameAnd the data compounds. High-quality speech data for specialized insurance vocabulary is scarce; no public dataset covers our referral codes or scheduling terms. Every call generates a fresh sample with a verified transcript — a corpus proprietary platforms never see, because on a self-hosted stack the calls never leave our infrastructure. That feeds better recognition, and in time a transcriber fine-tuned on our own callers that no general-purpose model can match on this vocabulary.
Then there is fine-tuning. The 25,000-character rulebook distilled into the model's own weights — latency dropping further, the cost per turn approaching the thermodynamic minimum: electricity through silicon. Fine-tune the synthesizer on our own audio, the cadence of explaining a policy excess and the rhythm of reading back an appointment time, and it sounds more natural than any general-purpose model. The stack absorbs every improvement the open-source community ships, and pays no one a margin.
Every open-source release lowers the cost curve and lifts the quality curve at once. A stack on your own GPUs and open weights captures the whole of that gift. A stack rented by the token captures none of it — the price is set elsewhere, and it reflects a margin, not a cost.
The freedom
There is an advantage here that is architectural rather than financial. The stack is assembled from open components — an encoder-decoder for transcription, a diffusion model for synthesis, a sparsely-activated engine for reasoning — and open components are not black boxes with fixed seams and opaque prices. They compose. Characters mangled in synthesis? A configuration flag, not a support ticket. Private reasoning leaking into the reply? A runtime parameter, not a platform release. Every optimization in this report was possible only because the stack is open and inspectable.
Topology is just as free. Today the GPUs sit in an EU data center; tomorrow they could move behind a hospital firewall so that no audio ever leaves the building — the same models, the same runtime, the same configuration. Data residency stops being a negotiation and becomes a line in a config file. For a medical booking agent in the European Union, that is not a preference. It is a requirement.
The ledger
We have a real-time, multilingual voice agent. It books appointments, answers questions, and hands off to a human operator when it should. A typical turn is about 800 milliseconds — comfortably inside the platform's quoted one-and-a-half to two seconds — with a clean turn near 600 and a complex one around 1.2. A dozen cloned voices. Domain-tuned transcription. Benchmarked well under a dollar per call, all in; at fifty concurrent callers, fifty-six per cent below the premium cloud. What stands between this and a finished product is not the voice pipeline — it is HL7 and FHIR compliance, GDPR-grade recording, multi-tenant isolation, human fallback with a clean handoff of context. Real problems, all solvable with infrastructure that already exists. The voice part is done.
It costs less per call than the electricity that keeps the room it runs in lit. Owning the means of producing a voice is not idealism — it is arithmetic.
The voice stack — open-source transcription, reasoning, and synthesis on a single GPU.
~800 ms typical turn · streaming synthesis · eight-bit KV cache · prefix-cached prompt · self-healing deploy · one-command bring-up.
Figures are measured on representative benchmark workloads and stated relative to a leading managed voice platform at our production volume.
The simulation is a deterministic voxel world that runs itself. There are no quests and no scripted NPCs — only a population of autonomous agents, a day cycle that is for working and trading, and a night that sends monsters out of the dark.
Each agent runs a real cognitive loop: it perceives a local neighborhood, scores its options, commits to a goal, plans a sequence of actions to reach it, and remembers what it sees. Stack a hundred of those loops on a shared map for a few hundred simulated days and the interesting behavior is the behavior nobody wrote.
These are notes on the machinery that makes that possible, and on what one seed-locked run actually produced.
The result, then the mechanism
By day 592 the colony had recorded 10,849 deaths — agents caught in the open after dark. The eye-catching part is that the town visibly reorganized itself around the danger: it routed travel away from killing grounds and pushed labor toward shelter and walls as dusk fell. That reads like fear. Under the hood it is something more precise.
The world maintains a coarse, decaying danger field over the map. A wound deposits 1.0 into its grid cell; a death deposits 6.0. The field fades at 0.97 per tick, so a killing ground is roughly half-forgotten in about twenty ticks unless something dies there again. Crucially, the pathfinder has no special rule for avoiding danger — it simply adds 4 × danger to the cost of stepping through a cell. A lethal tile therefore reads as if it were dozens of tiles further away, and routes bend around it on their own.
So the colony's "memory of where it is dangerous" is literally a scalar field with a deposit rule and a decay constant, and its "fear" is that field leaking into a cost function. You can watch it accrete after a bad night and evaporate over a quiet week. The slow mind, running separately, narrates the same state from the inside — beliefs that hardened across the population and were recorded verbatim:
“The nights are claiming too many of us.”
a belief recorded in common across the colony — emergent, unscripted“The wilds are claiming too many of us, so I'm reinforcing every wall before dusk.”
generated reflection · the same state, narrated from the insideThe field is the mechanism; the sentence is the colour. Neither was authored. That pairing — a legible numeric system, and a slow mind that gives it a voice — is the whole design.
The core architecture
The hard constraint in this kind of agent world is latency. A slow-mind call costs hundreds of milliseconds; a believable town needs hundreds of decisions per second. So each agent carries two minds, and they run at completely different rates.
▸ Fast mind · every tick
A utility-AI scorer feeding a GOAP planner. Pure code, no network. It decides what to do and computes the steps to do it, hundreds of times a second, identically on the same seed.
▸ Slow mind · off the hot path
Thoughts, dialogue, daily reflection, building design. Dispatched asynchronously and capped in-flight; results are queued and applied on the tick thread, so a slow call never stalls the world.
The fast mind makes the town run; the slow mind makes it legible to a human watching. The decisive choice is keeping the slow mind strictly off the simulation's hot path — present everywhere as voice, never as a blocking dependency.
Under the hood
Most of what looks like intelligence in the simulation is a handful of small, classical algorithms composed on a shared world. None of them is individually exotic; the behavior is in how they interact.
Every tick an agent scores a shared goal set — gather, build, trade, research, defend, shelter — through a personality weight vector, not a separate code path per type. A single safety term, safe = (1 − 0.8·threat)·(0.35 + 0.65·daylight), multiplies every work goal, so productivity collapses near a monster and after dark and recovers at dawn — a continuous field, not a state machine. The winner isn't taken greedily: the agent samples among goals within 82% of the top score, so identical agents diverge. And it commits for a short randomized stretch to avoid dithering — but a hard need (hunger, nightfall) breaks the commitment instantly.
The tech ladder — wood → stone → iron → diamond, smelting, armour, beds — is not hand-coded. It's a set of declarative actions with preconditions and effects; a means-ends planner backward-chains from a goal to the deepest action executable right now and replans each tick. Change a recipe and the plan re-derives itself. That's the line between planning and a fixed if-ladder.
Deaths and wounds deposit danger into a coarse grid that fades every tick; the pathfinder folds it straight into edge cost (cost += 4 × danger). No avoidance logic — risk-aware routing falls out of arithmetic. This is the machinery beneath the result above, and it's why the avoidance is graded rather than binary: a tile that killed someone last night is given a wide berth; one that killed someone last week barely registers.
Nobody plans streets. Each agent drops a faint scent on every tile it crosses — heavier when hauling goods — and the scent decays slowly. Busy supply lines pack down into worn roads; abandoned paths fade out. It's ant-colony stigmergy: the road network optimizes itself from a few million footfalls, and the renderer simply draws whatever has worn in.
Gathering wood pays exactly what wood currently sells for. So when the chest runs low and the price climbs, the effective wage rises and labor floods into gathering; a glut drops the price and drains labor back out to other work. The workforce reallocates itself across a single price signal — a one-line wage function standing in for a central planner.
The slow mind runs on a thread pool with a hard in-flight cap (6 conversations, 8 plans). Results never mutate sim state directly — they're marshalled onto a queue the tick thread drains at the top of each tick, the same discipline as player commands, so there are no cross-thread races. Hit the cap or stall a call and that agent silently falls back to a deterministic template; the simulation never waits. Caching and a hard cost ceiling bound the bill.
Every stochastic draw comes from one seeded generator per world — ~55 call sites routed through it, including the spatial queries, which bucket the map into 8-wide cells and scan a 3×3 neighborhood (verified to match the brute-force O(n²) scan exactly). Same seed in, identical run out, down to the order of every birth and death; the generator's state is saved and restored, so a resumed world continues the exact stream. Reproducible in fact, not just in principle.
From memory to behavior
The danger field handles where it's dangerous. A parallel, four-stage pipeline handles what the town comes to believe, and it is the line that produced the emergent dread:
Witness. An event fires — a death, a theft, a structure finished. Every agent within an 18-tile radius records it, tagged with a salience score for how much it mattered; a death is maximal, a routine trade negligible.
Gossip. When two agents talk, only memories above a salience threshold hitch a ride. A retold memory becomes the listener's own, which they retell in turn — news propagates through the conversation graph rather than by broadcast.
Belief. Accumulated salient memory hardens, via the slow mind, into a stance about the world. “The nights are growing too dangerous.” “Word travels fast in this town.”
Action. Beliefs feed back into the fast mind's goal scoring, tilting the weights. The loop closes — and what began as one bad night can become a town-wide policy of building walls before dusk.
Population dynamics
Population isn't a fixed number. Carrying capacity is recomputed live as min(housing, land, food) under a hard cap, and new arrivals appear stochastically only while the town sits below it — a logistic growth curve with no target baked in.
The run settled around 127 agents against a capacity near 102. That overshoot isn't a bug: structures are destroyed on bad nights, which knocks capacity down beneath a population that's already standing, while existing agents don't vanish to match. The result is a living tension between births, building, and nightly losses that the colony negotiates on its own, tick after tick.
A load-bearing system, idle by design
The town split into two factions early — anchored to districts and to high-renown leaders. The conflict system behind them is complete: armour tiers, weapons distinct from work tools, per-faction barracks, war chests, conscription, sieges, captured territory, ransomed prisoners, rare permadeath last-stands, treaties, and a stone memorial raised when a war ends.
⚔ wars fought in 592 days: 0 — standing: allied
Across the entire run, that machinery sat idle. War is gated behind sustained, mutual hostility plus two armed musters, so it has to be earned, not stumbled into — and left alone, two prosperous neighbors drifted to an alliance instead. The interesting outcome was the system never having to fire. It only reads as restraint because the alternative was fully built and genuinely reachable.
Cost
Because the slow mind is off the hot path and called sparingly, a whole population's interior monologue is nearly free. In a representative window the slow mind made 101 calls for a total of $0.0114 — about one hundredth of one cent per thought. The economics, not just the latency, are why it can be everywhere.
Field report — the 592-day runseed-locked · replayable
The deterministic fast mind runs identically whether or not the slow mind is attached at all — the world never depends on it.
We wrote a set of small, legible rules. The colony wrote everything that mattered.
The simulation — an agent-driven voxel world.
~4,900 lines of deterministic simulation · 207 passing tests · per-world seeded RNG · two-speed cognition (utility-AI + GOAP fast mind, async slow mind) · decaying danger field · stigmergic road network · price-cleared labor market · live three.js viewer over WebSocket.
Quoted reflections are verbatim from agents in the run. We wrote the rules; the simulation wrote the rest.