Caltor writes software. Agents, retrieval systems, copilots, decision systems and the applications that put them in front of the people who do the work.
This is the flagship practice, and the plainest thing we can say about it is that we write software. We do not sell decks about software, and we do not leave a prototype for another firm to finish. Caltor designs, builds and ships production systems: the model work, the data path around them, the integrations into your estate, and the application your people actually open.
What we actually build
Most of our work takes four shapes. We build agents that plan and execute multi-step work with a person in control and every action recorded. We build retrieval systems that answer from your own documents and data rather than from the open internet. We build copilots that sit inside the tools your teams already use, and decision systems that score, rank or route the cases a person would otherwise read one at a time. Around all of it we build ordinary application software: the interfaces, workflows, permissions and integrations without which none of it reaches the people doing the work.
Evaluation is the acceptance criteria
An AI system without an evaluation suite has no definition of done. Before we build, we write down what a correct answer looks like for your cases, in your language, with your edge cases included, and we turn that into a suite the system has to pass. Evaluation then becomes the contract: model changes, prompt changes and retrieval changes ship behind it the way code ships behind tests. When a model provider changes something underneath you, the suite tells you what moved before your users do.
The threat model is part of the architecture
Anything that reads your data or acts on your systems changes your attack surface, so we write the threat model alongside the architecture rather than after it. We name what the system may read, what it may write, which identity it acts under, and what a hostile input could persuade it to do. Prompt injection, exfiltration through retrieval and over-broad tool permissions are design questions here, not findings in a later report. The partners built and still operate an attack-surface management platform of their own, so this is habit rather than policy. Your security team is welcome in the reviews.
Built to be operated by your team
A system only its authors can run is a liability. We instrument what we build so that cost, latency, failure modes and answer quality are visible on a dashboard your engineers own, and we write the runbooks that say what to do when something breaks: how to roll back a prompt or a model, how to reindex, who to page, and what normal looks like. Handover is a deliverable, not a favor at the end. We work inside your cloud accounts and identity systems, so the system is already running where it will live.
You own the work outright
Every contract assigns the work product to you: source code, prompts, evaluation suites, documentation and infrastructure configuration. We keep only our pre-existing tools and general methods, and those are named in the agreement so there is no argument about it later. Nothing we build for you is resold to anyone else, and nothing is withheld to make you dependent on us. The test we hold ourselves to is simple. If you ended the relationship tomorrow, your team could keep the system running and keep changing it.
What you get
A working system in your production environment, running on your cloud accounts and under your identity provider.
An evaluation suite written against your own cases, which the system has to pass before anyone calls it finished.
A threat model and security review covering data access, tool permissions and the identity the system acts under.
Observability wired into the system, so cost, latency, failure modes and answer quality stay visible to your team.
Runbooks and handover documentation written for the engineers who will operate the system after we step back.
Full assignment of the source code, prompts, evaluation suites and infrastructure configuration to you.
Evidence
Antenna is a social media studio we built and released as open source, which means the engineering standard described on this page can be read rather than taken on trust.
This is not a team you rent by the head. We do not sell people into your backlog to work under your managers, and where our engineers do sit inside your organization they stay accountable to us for the work, and we are not a proof of concept factory that hands you a demo and an invitation to industrialize it yourself. We take responsibility for a system reaching production and working there. If what you need is extra hands on a plan you already own, a staffing firm will serve you better than we will.
Send us the problem and the systems it touches, and a partner will come back with an architecture, the risks worth naming, and what the first working version should do.
