How we build it.
This page is for the person who gets asked "is this legit?" It covers the architecture, the models, how data is handled, how we test, what we monitor, and what the client owns. No marketing language. If something you need isn't here, ask and we'll answer in writing.
What we build, in one paragraph
Each client gets a custom system with three layers: a knowledge layer built from their documents, systems and conversation history; a model layer that uses current frontier language models through their business APIs; and an action layer that connects to the client's existing software so the AI can do things, not just answer. On top of that sit the channels the client actually uses: a web application, internal tools, and voice, chat and text agents. We design it, build it, test it with the client, run it and keep it current as models and the client's business change.
Architecture
Knowledge layer
Answers are grounded in retrieved source material (retrieval-augmented generation) rather than the model's general knowledge. Sources are chunked, embedded and indexed; each answer can cite the document or record it came from. Sources are re-indexed on a schedule or on change, so the system reflects current prices, policies and records rather than a snapshot.
Model layer
We use current frontier models from the major providers through their business APIs, selected per task for quality, latency and cost. We don't train or fine-tune public models on client data. When a provider ships a better model, we evaluate it against the client's test suite and roll it in as part of the managed service. The client doesn't need to know or care which model is running.
Action layer
Integrations use the target system's official API, webhooks or OAuth where available. Each connection is scoped to the minimum access needed (read first, write only where the workflow requires it). Actions that change records, send money, commit to customers or alter bookings run through an approval step by a named person unless the client explicitly decides otherwise for a specific low-risk action.
Voice, chat and text agents
Conversational agents run on a telephony and messaging platform connected to the same knowledge layer. They identify themselves as AI at the start of every conversation, hand off to a person on request or on defined triggers (upset customer, out-of-scope question, high-value decision), and log every conversation. Call recording follows the client's state consent requirements.
What a call leaves behind
Every conversation is logged with what the agent did and why. A sample record, so you can see the shape before you ask for the real thing.
- Caller
- New contact createdName and number added to your customer records.
- Request
- Tagged: new build, Linden Hill, spring start"Bought a lot" matched your new-build rule.
- Action
- Booked Thu 10:00 AM, site visit with DanielWritten to your calendar. Site visits are on your pre-approved list, so no sign-off needed.
- Handoff
- Not triggeredNo pricing commitment, no upset caller, no out-of-scope question.
- Message
- Confirmation text sentFrom your number, with the lot address and Daniel's name.
- Recording
- Kept 90 daysYour retention setting. Deleted on request.
- Sent to
- Your customer records and calendar. Nothing else.
Data handling and security
We use business and API tiers whose terms exclude training on customer data. Client data is used only to serve that client's system.
TLS for every connection. Encrypted storage for indexed knowledge, logs and recordings.
Per-user and per-role permissions. A team member, a customer and an owner each see only what they're allowed to. Integration credentials are stored in a secrets manager, never in code or prompts.
Conversation logs and recordings are kept for the period the client chooses and deleted on request. Full export on exit.
Each client's knowledge base, credentials and logs are separate. No shared index between clients.
Every action the AI takes against a client system is logged with what it did, on whose behalf, and what it was based on.
Accuracy, testing and guardrails
- Grounded answers. The system answers from the client's sources and can show where an answer came from. When it can't find support, it says so and offers a person, rather than guessing.
- Scenario test suite. Before go-live we build a set of real situations from the client's actual calls, emails and edge cases, and the system has to pass them. The suite grows over time and re-runs whenever a model or a source changes.
- Approval gates. Anything with money, commitments or customer records attached waits for a person unless the client has explicitly cleared that action.
- Handoff rules. Defined triggers move a conversation to a human. The customer can always ask for one.
- Monitoring. Conversation logs, failure flags and handoff rates are reviewed as part of the managed service. Regressions after a model change are caught by the test suite, not by the client's customers.
Delivery
| Stage | What happens | What we need from you |
|---|---|---|
| Discovery | Map the workflow, the systems involved, the data sources, the risks and the approval points. Scope and price in writing. | Time with the owner and the people who do the work today. Read-only access to the relevant systems. |
| Interactive demo | A clickable, working demo of the actual workflow on the client's own data where possible, usually within about two weeks of receiving what we need. | Documents, sample conversations, a point person for questions. |
| Build and test | Full build, integrations, test suite from real scenarios, review sessions with the client's team. | Write access where the workflow needs it, test participants, sign-off on approval rules. |
| Launch and run | Go-live, monitoring, model upgrades, security updates, source re-indexing, changes as the business changes. | A contact for questions. That's about it. |
What the client owns, and what happens on exit
- Yours: all documents, data, content, recordings, conversation logs and anything the system produced for you. Exportable in standard formats at any time and on exit.
- Ours, run for you: the system itself (the knowledge pipeline, prompts, integrations, evaluations and infrastructure). It's a managed service, so it stays current without you maintaining it. It runs while the service runs.
- On exit: written notice, a full export of your data and content, and a transition window where we help your next provider or team pick up the integrations.
Due diligence checklist
Things we're happy to provide or walk through on a call:
Where each type of data lives, moves and is stored, per client.
The specific model and platform providers used for your build and their data-use terms.
Which systems we connect to, with what scope, and how credentials are stored and rotated.
What the scenario tests look like and how pass/fail is judged.
Who you call, how fast we respond, and how a bad answer or failed action is handled and prevented from recurring.
Exactly what an export contains and the format it comes in.
Questions this page didn't answer?
Send them over. You'll get a written reply from the person who builds it.