We think about AI adoption in four levels. Most companies are stuck at the first one. The interesting work is moving up the stack.
1. Process — structured workflows over clean data
The foundation is boring and non-negotiable: organized, accurate data and workflows that run the same way every time. The shape that keeps showing up is ETL → synthesis → deliverable. Pull the data in and clean it, do the analysis, produce the thing someone uses. Get targets right and the rest follows.
where we've built this: An ecommerce data warehouse where Shopify and ad data are modeled in dbt into attribution and cohort marts. A deep-research engine that searches, extracts evidence, synthesizes, and delivers a cited report. A knowledge base that ingests documents, breaks them into scored claims, and serves them back.
2. The individual — the mech suit
This is where most of the near-term value is, and it's the level people describe worst. AI doesn't replace the person. It's a mech suit. And the suit is concrete: a desktop AI app, hooked up to connectors for the systems that person already uses — their store, their email platform, their docs — scoped to their access, with a library of governed skills loaded on top. A normal human gets powered up. They think faster and more strategically because they now have bounded, accurate business data and tools that do actual work behind them. Same person, amplified reach.
The key word is bounded. The suit only reaches what the person is allowed to reach, and the skills only produce drafts a human reviews. A powered-up human working from accurate, scoped data and guardrailed tools makes better decisions faster. A human working from a chatbot's guesses makes confident mistakes.
where we've built this: Client-operated skill libraries where a non-technical store owner runs agency-grade work themselves — a researched blog post, an email campaign, a social plan — every output a draft they review, with a setup skill that wires up and verifies their scoped connectors. The operator isn't coding. They're wearing the suit.
3. The organization — connected data and agents with comms
This is the newest level and the one almost no one has. You pipe interdepartmental datasets together with fast read/write, so agents can work across departments instead of inside one silo. The organization builds its own custom connectors and trained agents — the shared resources every mech-suited employee can reach from inside their own suit. Then you give the agents communications, the same channels the humans use, and let them work together. The mech-suited humans get instant flow of information; the trained agents get their own handles — a Slack account, an email address — and can be called like a colleague.
The result is an organization where information moves at machine speed between the people and the agents, and where "ask the specialist" is a message away whether the specialist is a person or a trained agent.
where we've built this: An intel platform with ~20 trained domain agents reachable from team chat, an API, and a custom bridge, backed by cross-project data piped into one hub. Agents you can call by name, from inside whatever suit you're wearing. An overnight orchestrator that works the backlog through the night and hands back reviewable drafts in the morning.
4. System management — HR, training, security, and failure
Once agents are doing real work, they need to be managed like a team. That's the top level: monitoring, quality review, retraining the weak performers, containing failures, and enforcing what each agent is allowed to touch. A monitoring fleet that runs the system.
This is the part people skip, and it's why their pilots quietly rot. An agent that isn't graded drifts. An autonomous agent without brakes is a liability.
where we've built this: An LLM-as-judge that scores every agent output before it ships, plus a weekly review that ranks the agents and rewrites the weakest one's training. A seven-layer safety model on the overnight orchestrator: draft-only output, a deny-list, context-aware hooks, cost caps, a kill switch, and a post-run verification gate. Per-tool-call audit logs. Error tracking and dead-man's-switch monitoring on every service.