What we do
Five lines, one parts list. Most engagements are one of them, sometimes two.
One shop in Vancouver, BC, working remotely with clients worldwide.
line 1
AI products, built end to end
- first surface:
- six to twelve weeks
- cadence:
- weekly shippable increments
What it is
We design and ship the whole product, not a demo. Model choice, tool and action layer, data model, the interface people actually touch, and the evaluation harness that tells you when a change made it worse.
What a client gets
A running product in production with its own tests, its own eval suite, and documentation that lets your team take it over. We hand back something maintainable, not a prototype with our name in the commit log.
A typical engagement
Six to twelve weeks to a first production surface. Week one is scoping and a thin end-to-end slice. After that, weekly shippable increments against a fixed set of acceptance criteria. If the product is agent-shaped, the agent gets real tools against real state from the first slice, because an agent that can only talk teaches you nothing.
line 2
Knowledge bases and retrieval
- duration:
- four to eight weeks
- starts with:
- your documents and your questions
What it is
Retrieval and embeddings over your own knowledge - filings, tickets, transcripts, wikis, code, contracts, whatever the answers are buried in. Ingestion, chunking, indexing, retrieval, grounding, and the evaluation that keeps it honest.
What a client gets
A retrieval system that returns the right passage and cites it. Structure-aware ingestion, hybrid search rather than embeddings alone, metadata filters that behave as hard constraints, and a golden-question set so you can prove a change helped.
A typical engagement
Four to eight weeks. It starts with your documents and your analysts writing the questions the system must answer. Most retrieval failures are ingestion failures, so the early time goes into parsing and chunking, not prompting.
line 3
Codebase and team optimization
- duration:
- three to six weeks
- first wedge:
- usually test generation
What it is
Making your repo legible to coding agents and your engineers good at driving them, which is the work that has to happen before AI-assisted development produces anything you keep. Repo-level instruction files, path-scoped rules, fast local feedback loops, test-generation workflows, and a written practice the team owns.
What a client gets
An audit of where AI currently helps and where it produces work you throw away, then the concrete changes: context files in the repo, checks an agent can run itself, and worked examples of good output in your codebase.
A typical engagement
Three to six weeks, usually alongside the team's normal work. We pick one high-value, low-risk wedge first - test generation is the usual choice - prove it, then widen. The deliverable is checked into your repo, not into a slide deck.
line 4
Training and enablement
- duration:
- sessions over two to four weeks
- format:
- hands-on, in your codebase
What it is
Teaching engineers, and the people around them, to work with AI tools on real work. Not a vendor demo. Your codebase, your tickets, your constraints.
What a client gets
Working sessions on the workflows that survive contact with production, written material the team keeps, and a short list of the things that reliably do not work so nobody rediscovers them one at a time.
A typical engagement
A block of sessions over two to four weeks, usually paired with line 3 - the training sticks when the repo has already been made agent-legible. We run it hands-on: people ship real changes during the session.
stack:Model providers, Agent frameworks
markets:Every market we work in
line 5
Forward-deployed engineering
- duration:
- ongoing
- measured in:
- deployments, not features
What it is
Embedded with your team, or with your customers' teams, building the custom integration work that a self-serve catalog cannot cover. Common when an AI platform has to reach into a different internal stack at every account.
What a client gets
Integrations built, validated end to end, and taken to production - auth, pagination, rate limits, retries, and the failure modes that only appear under real traffic. Business rules expressed as typed tools with explicit contracts rather than as prompt instructions.
A typical engagement
Ongoing, measured in deployments rather than features. We push recurring patterns back into your platform so the next customer gets a supported capability instead of another one-off. Without that discipline, forward-deployed work is a treadmill.
How we work
The same shape on every line. Durations are not one of the constants: each line above states its own.
- scoping:week one, before anything is builtok
- first slice:thin, end to end, against real stateok
- cadence:weekly increments, fixed acceptance criteriaok
- handover:tests, evals, and docs your team can runok
- duration:per line, never a single global numberok
Not sure which one you need?
Describe the problem and we will tell you.
Start a project