How we work · in depth

The architecture behind the approach

A deeper walkthrough of how a DataStudios agent is built so it can be trusted and reused — the layers that make it reliable, the part that generalizes across clients versus the part that's specific to you, and how autonomy is earned. The plain-language version is on How we work.

The fuller version — for a deeper walkthrough

The capability stack

An agent that earns autonomy isn't a script — it's a layered capability. Each layer has a job, and keeping them separate is what makes the work both reliable and reusable.

Layer	What it is
Skill — the recipe	What the agent does and in what order, plus the acceptance checks. A thin plan that composes the tools below; it holds no hidden logic.
Tools — tested logic	The reusable, tested building blocks (connectors, matchers, the per-row exclusion log). The parts that must be correct live here, each backed by checks.
Eval — the proof	A set of known cases the agent must get right, run every time something changes. This is what earns each step of autonomy and keeps improvement safe. See the golden cases →
Registry — your settings	The per-client configuration: your IDs, your schema, your match keys and windows. Onboarding a client is binding this layer — not rewriting the agent.
Runtime — the loop	What actually triggers and runs it on a schedule, and the surfaces you watch it through. See it run →

Why thin-skill-over-tested-tools matters. Cramming the must-be-correct logic into the recipe makes it unverifiable and brittle. Keeping the recipe thin and the critical parts in tested tools is what lets us prove the agent works — and reuse it without it breaking.

What generalizes, and what's yours

Decompose any automation and you find three layers with very different reuse. We build the first one concretely, factored along these seams — so the next client reuses the general parts instead of starting over.

Layer 1 · the loop
General machineryRead the source of record → match → write (validated, gated) → reconcile → verify. Plus the cross-cutting safeguards: idempotency, the per-row exclusion log, reconcile-to-source, the human gate.
reused across every engagement
Layer 2 · adapters
Platform connectors"Read this CRM," "write to this ad platform." The coupling to a specific system is real and fine — isolated behind a uniform interface so it's reused per platform, never smeared through the work.
reused per platform
Layer 3 · your instance
The compositionThe general loop plus the chosen connectors, bound to your IDs, schema, and rules. This is the part that's specifically yours.
your engagement

We derive what generalizes from real instances, not from guesswork. The first build is concrete but factored along these seams; the second proves where the real reuse is before we extract a shared library. That discipline is why the portfolio stays one well-tested approach rather than a pile of bespoke scripts.

The phase contract

The agent runs the same ordered set of phases every cycle. Two are gated — the steps that can't be undone — and the agent stops there for a human.

1Capture→ 2Resolve→ 3Build→ Validate→ Upload→ 6Reconcile→ 7Monitor

Everything up to Validate is read-and-prepare — it can run unattended once its checks prove out. Validate is the last safe step (a dry-run that stores nothing); Upload is the one that writes, and it's held for approval. After it, the agent reconciles across systems and refreshes the view you supervise.

This isn't a diagram — it runs. These exact phases execute against your real systems, with the write step held at the gate. Watch a real run, step by step → See it run.

Autonomy, rung by rung

Autonomy is granted per phase, by evidence — never wholesale. The human checkpoint climbs as the proof accumulates; it never just disappears.

todayAssistedThe agent runs nothing irreversible. Prepare + validate → you approve → go-live. You see every step.

nextApprove-runThe read-and-prepare phases run unattended; a human approves one batch.

thenBy-exceptionThe full cycle runs on proven phases; a human reviews anomalies and new cases only.

payoffBuilderThe agent proposes and stands up new work itself — onboarding becomes an agent action, run gated.

What promotes a rung is evidence, not time — the golden cases the agent must keep passing for the phases it covers. See the proof that earns autonomy → Evals.

The delivery loop

How the work actually moves — with a checkpoint you control at the end.

We plan in a private workspace and run against your live systems in a separate, controlled environment. The loop: write a spec with acceptance criteria → the agent executes it (does the work, runs its own red/green checks) → we verify the result against the criteria, and you approve anything irreversible → accept, or refine and repeat. The work and its run-logs are versioned together, so the evidence always travels with the thing it proves — and the map never drifts from the territory.