Getting Started

Every engagement begins the same way: you describe a workflow that hurts, in plain words, through the contact page or a booked call. Within 24 hours an engineer replies — with questions, not a brochure.

The first call is 30 minutes and free. We map the problem, the data you have, and what success would measurably look like. You leave that call knowing three things: whether AI is even the right tool, roughly what a build would involve, and what we would do first. If the honest answer is "you need a spreadsheet, not a model" — that is the answer you get.

Before the first call No preparation is required, but two things speed everything up: a rough sense of where hours are being lost, and whoever knows the current workflow best in the room.

Engagement Phases

Builds run in four phases, each ending with a decision point — commitment scales with demonstrated results, never ahead of them.

  • 01 — Discovery & Feasibility. Requirements mapping, data audit, and honest feasibility answers. Output: a scoped plan with success metrics agreed in writing.
  • 02 — Proof of Concept. A working system on your own data, measured against the agreed metrics. Weeks, not quarters. Output: real numbers, and a go/no-go you control.
  • 03 — Production Build. The PoC hardens: integrations, evals, load testing, monitoring, and the unglamorous half of AI engineering that keeps systems alive.
  • 04 — Launch & Improvement. Deployment with dashboards and a runbook, support through the first production cycles, then an iteration cadence or a clean handover — your choice.

Timelines vary by scope and are quoted per project after discovery — a proof of concept typically lands within weeks, and first production deployments within a few months. Any number quoted before discovery is a guess; we don't quote guesses.

Communication Rituals

We are a remote-first, written-first team, and engagements inherit that discipline:

  • Weekly demos. You see working software every week — not status decks. If a week has nothing demoable, the demo says exactly that and why.
  • A written trail. Decisions, scope changes, and trade-offs land in writing where both sides can find them later. Verbal agreements get confirmed in text the same day.
  • One responsible person. Every project has a named delivery owner — your single point of contact, with the engineers one message away.
  • No surprise policy. Risks are raised when they appear, not when they explode. You will sometimes get news you don't enjoy; you will never get it late.

Deliverables & Handover

You own everything we build, from day one, in your own accounts:

  • Source code & models — repositories, trained weights, and training pipelines, in your organization's accounts, not ours.
  • Infrastructure as code — the environments are reproducible from files, not from someone's memory.
  • Documentation — architecture notes, runbooks, and the "how do I…" guide your team will actually use.
  • Knowledge transfer — handover sessions with the engineers who built the system, recorded for the teammates who join later.

There is no lock-in mechanism anywhere in this list, by design. Our retention strategy is being worth keeping.

Quality & Measurement

"It works" is not a metric. Before building, we agree what the system must achieve — detection accuracy, hours saved, latency budget, cost ceiling — on your data, at your operating point. The proof-of-concept phase exists to measure against exactly those numbers before the full build is funded.

After launch, the same metrics move into dashboards: accuracy tracked in production, drift flagged when input data shifts, costs attributed per request. Success stays visible — and auditable — for as long as the system runs.

Related reading The research collection publishes the measurement methodology behind claims we make — starting with what INT8 quantization really costs.

Security & Data Handling

Your data is yours, and it behaves that way throughout an engagement:

  • Access is scoped and revocable — we work inside your accounts under least-privilege access you control and can cut at any time.
  • Data stays where you need it — on-premise and fully local deployments are first-class options, not workarounds; for vision and edge systems, raw footage never has to leave your site.
  • Training data is handled deliberately — anonymization and preprocessing before anything reaches a training run, retention agreed per project.
  • Compliance-aware builds — engagements can target the regulatory requirements your industry carries; constraints are scoped in discovery, not discovered in production.

Engagement Models

Three shapes cover nearly every engagement:

  • Phased fixed-scope — the default. Each phase priced and scoped in advance, with the go/no-go between phases keeping risk on our side of the table.
  • Post-launch retainer — an ongoing iteration cadence after launch: monitoring, retraining, and roadmap work with the team that built the system.
  • Handover & exit — full transfer to your internal team with documentation and training. Choosing this option is always available and never penalized.

Pricing is quoted per project after discovery, in writing, with the scope it covers. Change requests get a real cost and a real decision — "small additions" are where budgets quietly die, so we refuse to treat them casually.

Glossary

Terms that appear across our proposals and this site, in plain words:

PoC (Proof of Concept)
A working system on your real data, built to measure feasibility against agreed metrics — not a slideshow about one.
Drift
The slow divergence between the data a model was trained on and the data reality now produces. Unmonitored, it is how systems die quietly.
Evals
Automated tests that score a model or pipeline against known cases — run on every change, so quality regressions surface before users find them.
Human-in-the-loop
A workflow where the system handles the routine and routes judgment calls to a person — automation of repetition, never of responsibility.
LLM wrapper
The software layer between your application and a model API — auth, caching, routing, guardrails, and observability in one place.
OTA (Over-the-Air)
Signed remote updates to models and firmware on deployed devices — staged rollouts, automatic rollback, no vans with USB sticks.
Quantization
Compressing a model to lower numeric precision (e.g. INT8) so it runs fast on small hardware — measured per step so accuracy loss is a decision, not a surprise.
Runbook
The operations manual we hand over with every system: what to check, what to restart, and who to call when reality misbehaves.