A forward-deployed agent does the building. You hold the gates. Five steps — discover, draft, validate, approve, publish — with a human decision at every point that matters.
Most integration tools hand you a canvas and wish you luck. Tajo works the way a good deployed engineer does: it studies the systems involved, proposes a concrete integration, proves its work against real checks, and then asks for sign-off before anything runs. The difference is that with Tajo, the sign-off is cryptographically enforced — what you approve is, verifiably, what executes.
The agent maps the systems on both sides of the integration. It works from a discovery corpus of 27 vendors and 10,345 documented API operations, plus a shape-only sample of your actual data — field names and types, never values.
A readable picture of what was found: which systems, which objects, which fields, and what the agent believes connects them. Nothing has been built or moved yet.
The agent drafts the integration: source, destination, field mappings, transforms, and the consent rules the sync must satisfy. Drafting is grounded in the discovered API operations, not guessed endpoints.
The full draft, in the open — every mapping and every rule, stated plainly enough to argue with. A draft has no permissions; it cannot touch a production system.
The draft is checked against the runtime's gates before anyone is asked to approve it: do the API calls typecheck against the real operations, do the mappings hold against the sampled shapes, and can the consent rules actually be proven for the records involved. Consent checks fail closed — a sync that can't prove consent doesn't run, so it doesn't pass validation either.
A pass/fail report per gate. Failures are specific — which mapping, which rule, which record shape — so the fix is a conversation, not archaeology.
The agent presents the validated integration for a decision. It cannot approve its own work: approval is a human action, and it is bound to a cryptographic digest of the exact configuration on the screen.
Exactly what will run — and a guarantee that it is what will run. The approval is single-use, tied to those precise inputs, and expires if unused. Change one field and the old approval is void.
The approved configuration is published under its digest. At execution time the runtime attests it is running exactly that digest, enforces the consent rules and budget caps, and gates any risky write behind its own single-use, input-bound approval.
A hash-chained, tamper-evident audit log of every run: what executed, under which approval, touching what. Evidence, not a dashboard's word for it.
Every step that could affect a production system passes through a human gate. Tajo's agent is fast at the drafting and checking; it is deliberately incapable of granting itself permission.
Digest-bound approvals close the gap between what you reviewed and what runs. There is no window for the configuration to drift between the approval screen and production.
Validation and consent checks fail closed. An integration that cannot prove it is safe and permitted stops at the gate — which is precisely what you want from software that writes to your customer systems.
The lifecycle above runs against Tajo's live runtime: 53 wired integrations, around 19 of them write-capable, with Brevo as the certified destination (seven typed targets) and HubSpot support emerging. The discovery corpus — 27 vendors, 10,345 API operations — is what the agent drafts from when your stack goes beyond what is already wired. The honest breakdown of what sits at each stage is on the integration readiness page.
Join early access and bring a real integration problem. We'll run the full lifecycle on it with you — gates, approvals, audit log and all.