Autopilot
for your company.

Every engagement starts with a fixed-price pilot around one workflow: one number, agreed in writing after the scoping call, before we build anything. The proposal also says what the pilot has to prove, in the numbers we baseline before the build. Once the pilot proves itself, ongoing pricing is a flat monthly fee per automated workflow — not per seat, and never a percentage of what the agents process. That fee is for keeping the loop running: monitoring, exception routing, credential rotation and the fixes when a vendor changes a field. The approvals themselves stay with your people — that is the point of the hold. We don't publish a list price because a pilot is scoped to your systems and volumes; a figure without that scope would just be marketing. You'll have yours in writing before you commit to anything.

LoopPilot designs, builds and runs AI-agent systems that operate one specific business workflow end to end — order processing, invoice handling, support triage and the like. Concretely: we map the workflow with you, wire agents into the tools you already use through scoped API credentials, test the loop against real cases, then take it live with human approval gates at the autonomy level you choose. What you get is a running system with an audit trail — not a chatbot, and not a pile of scripts your team has to maintain.

Usually yes if the workflow runs at least weekly, lives across two to five tools — ERP, CRM, helpdesk, email, spreadsheets — and follows rules with a manageable number of exceptions. Probably not yet if the workflow isn't defined, if it's a one-off project, or if it has to be fully autonomous from day one; loops earn autonomy over time, they don't start with it.

Often you should, and we'll say so on the call. If the workflow lives inside one system, build it with that system's own automation. If you have engineers with spare capacity and someone who will still own the thing in six months, build it yourself. What we're for is the case in between: a workflow that crosses two to five systems, has real exceptions, and needs somebody to operate it after go-live — the monitoring, the credential rotation, the exception routing, the morning the ERP changes a field. Rule-based tools break on the exceptions; internal builds usually reach a working prototype and stall on the operating half. We do both halves, and everything we build works through your accounts and your systems — your records never move to a platform of ours, so there is no data to migrate back if we part ways.

Classic automation follows fixed rules: if this, then that. It works until the input changes shape — a supplier renames a field, a customer writes the request in their own words — and then it stops or does the wrong thing. An AI agent reads the situation, decides what the step requires, uses the tools it has and adapts to the input, so you don't have to write a rule for every scenario. The catch is that a system which decides can decide wrongly, which is why every loop we build has confidence thresholds, a mandate it can't exceed and a human hold where it matters.

Two different failures, two different answers. The one we design for: below its confidence threshold or outside its mandate, an agent doesn't guess — it holds and escalates to a human, exactly like the approval hold in the console replay on this page. The one we plan for anyway: an agent acts confidently and is wrong. Then the audit trail shows which agent did what, with which data and when, so the action can be traced and corrected in the system it happened in — and that step drops to a lower autonomy level until it has earned its way back. Every workflow launches at the autonomy level you choose, and actions at lower levels are reviewed before they execute. And if you ever want a loop to stop, revoke its credentials — it has no access you didn't grant.

Your records stay in your systems — we don't copy them into a platform of ours. Agents read and write through scoped API credentials you grant, and can start read-only. One thing does leave: the specific content an agent has to reason about — an invoice line, a ticket body — goes to the model provider named in your engagement agreement, under terms that forbid training on it. Everything an agent does is logged to an audit trail you can inspect. Details are in our privacy policy.

Yes, and early. Before we quote the pilot we confirm API access for each system with the people who own it and agree the scope of every credential with them. Access is granted per agent, limited to its task and revocable from your side at any time — pull the credential and the loop stops. Send your security questionnaire to [email protected] and we'll answer it line by line.

That's the model: agents operate the tools you already run — CRM, helpdesk, accounting, commerce, email, spreadsheets, databases — through their APIs, with credentials you grant. We don't sell a fixed connector catalog; in the scoping call we map the exact systems in your workflow and confirm API access for each one before we quote the pilot. If something in your stack can't be reached cleanly, you hear it then — not after you've committed.

We scope every pilot around a single workflow precisely so the build takes weeks, not quarters. To be straight about the clock: it starts when we have API access and a named process owner, not at the first call — credential provisioning and your security review are the two things that move the date, so the proposal schedules both instead of quoting a date we don't control. The first thing you see is the mapped workflow and its exception list, then the loop running against real cases before it touches anything live, then go-live. “Results” has a definition in the proposal, not just a date: in Define we baseline the workflow's volume, cycle time, human touches per case and exception rate, and the same numbers tell you after go-live whether the loop paid off. After that we expand to the next workflow.

One process owner who can give us roughly two hours a week during the pilot, scoped and revocable access to the tools in the workflow, and a decision on where the human approvals sit. We handle the rest — mapping, build, testing and the go-live.