Technology
Built on InteractiveAI. Shipped by Agents Makers.
Every role in the catalog runs on InteractiveAI, the enterprise AI runtime built around per-turn governance and full decision interpretability. Agents Makers is the Operating Partner that turns the runtime into a hireable role: we scope it, deploy it, tune it, and stand behind the outcome.
This page is the operator's read on the stack. For the framework specification itself, head to interactive.ai.
Powered by InteractiveAI's Interactive Agents framework. Agents Makers is an independent Operating Partner deploying roles on top of InteractiveAI's runtime. The framework itself, including the policy engine, the per-turn evaluator, and the lifecycle tooling, is authored and maintained by InteractiveAI. This page describes how we use it.
Why this runtime
We deploy exclusively on InteractiveAI. Here's what made the call.
Most enterprise AI frameworks force a tradeoff. Either you get rigid control (and the agent breaks the moment a user pivots off the documented happy path), or you get flexible reasoning (and you can't fully trust it to follow the rules that matter). We evaluated three categories: monolithic system-prompt agents, workflow-graph frameworks like LangGraph, and skills-based modular agents. Each one fails differently at the volume an Agents Makers deployment actually runs at.
InteractiveAI takes a different approach. At every turn of an interaction, a structured engine reads the current state and assembles only the precise behavioural rules required for that exact moment. The model sees a focused, relevant subset of the role's policies, never the full library. High- criticality rules (compliance, escalation, safety) are evaluated on every iteration, structurally enforced rather than left to the model's discretion. The architecture is covered in detail on the InteractiveAI website.
The four practical consequences for an Agents Makers deployment are:
No instruction fatigue
Vector retrieval injects only the Top-K relevant policies per turn. Adding new business rules doesn't degrade reliability — the model is never overwhelmed because it never sees the full library at once.
Native handling of compound questions
When a user asks a multi-part question or pivots topics, multiple relevant policies activate in parallel. No rigid routing, no "sorry I can only handle one thing at a time" handoffs.
Per-turn enforcement of critical rules
Compliance, escalation, and safety policies are evaluated on every iteration. The model can't drift away from a regulatory requirement — the engine enforces it structurally.
Plain-language tuning
Every model decision traces back to a specific natural-language policy. When a deployment needs adjustment, we edit the policy responsible. No prompt-engineering archaeology, no code change.
The Operating Partner layer
The runtime is the engine. Agents Makers is what gets the role into your business.
Buying the runtime is not the same as having a working role. Between "great framework" and "Support Agent handling 60% of inbound tickets inside 60 days" there is a full operating model. That model is what Agents Makers ships, and it is what lets us stand behind the 90-day operational guarantee.
Layer 1
Scoping that lands the right role, not a generic template
Every deployment starts with a 1-2 week scoping sprint. We map the queue, the SOPs, the integrations, the escalation path, and the contracted KPI. The role is shaped around your operating model, not the framework's defaults.
Layer 2
Policy authoring grounded in your existing material
We translate your help-center articles, internal SOPs, and ticket history into the natural-language policies the runtime evaluates. Your domain expert reviews and approves before anything goes live. No black-box prompt engineering.
Layer 3
Integration into your existing stack
Connectors land in the systems you already run (Zendesk, HubSpot, Stripe, NetSuite, Salesforce, and 60+ others). The role uses scoped credentials, every action is logged, and your existing dashboards stay the source of truth.
Layer 4
Named Operating Partner + weekly tuning
One accountable person from our side through scoping, launch, and the first 90 days. Weekly review of escalations, false positives, and KPI delta. Monthly business review against the contracted target.
Layer 5
Continuous improvement via traces + memory
Every action the role takes is traced. The Co-Pilot analyses traces and suggests policy edits. Memory captures both autonomous learnings and human feedback. The role gets sharper week over week, measurably.
Layer 6
The 90-day operational guarantee, in writing
Outcome KPI signed in scoping. If the role hasn't hit it by day 90, we keep working at zero additional retainer cost until it does. The runtime is what makes that promise defensible.
How a deployment lands
The shipping process we run for every role.
Every Agents Makers deployment moves through the same five phases. The runtime gives us the tooling for each one. Our job is the work between the tools.
Phase 1 · Scope
Pick the queue, map the runbook
We pull 60-90 days of your existing volume, cluster the top intents, document the current SOPs (or extract them in scoping if they live in someone's head). Output: a signed scope with the contracted KPI, the role's capability set, the integration list, and the escalation policy.
Phase 2 · Author
Translate the runbook into runtime policies
Your SOPs become natural-language policies the InteractiveAI engine evaluates per turn. High-criticality rules (compliance, escalation, safety) are tagged so the engine enforces them on every iteration. Your domain expert reviews and signs before deployment.
Phase 3 · Integrate
Wire the role into your stack
Scoped credentials to your help-desk, CRM, billing, and document store. Knowledge base grounded in your real content. Dry-run on the previous 30-60 days of work to validate the role would have done the right thing before it acts on live volume.
Phase 4 · Launch + tune
Live with weekly ops review
Role goes live on the queue. Weekly review of escalations, false positives, and KPI delta. Policy edits land the same week the issue surfaces. By week 4, the leading indicator is visibly moving on your existing dashboard.
Phase 5 · Day 90 + beyond
KPI review, then expansion
We read the contracted number off your dashboard with you. If it's hit, the engagement moves to standard operation and we scope the next role or capability. If not, the operational guarantee covers continued tuning at zero additional retainer cost until it is.
The connection to the guarantee
The 90-day guarantee only exists because of this stack.
Promising an operator we will hit a contracted KPI inside 90 days, and keep working free until we do, is only defensible if we can debug, tune, and ship a fix the same week the problem surfaces.
On a system-prompt agent, a fix means rewriting the master prompt and praying nothing else regresses. On a workflow graph, it means a graph redesign. On both, the next operator deployment looks like the previous one minus the lesson learned.
On the InteractiveAI runtime, the trace tells us which policy fired, why, and what context drove it. The fix is editing one natural-language policy. No prompt-engineering archaeology, no graph migration, no code change. The next deployment ships tighter than the last.
The guarantee is the surface. The runtime is what makes the surface defensible.
90-day operational guarantee. We agree on the outcome KPI before launch. If we haven't hit it by day 90, we keep working free until we do.
Want to see this in motion?
30-minute call. We'll walk through a real deployment trace, show you how policies + governance look from the operator side, and answer the architecture questions your engineering team is going to ask.
The runtime under every role: InteractiveAI