How It Works

An agent that works
inside the systems you run.

We connect your systems, configure the agent, and put it on a schedule. You watch it work and read what it did.

The Flow

From work arriving to work done, on the record.

Two pillars run this path together: an AI workforce that does the work, and the infrastructure that gives it somewhere safe to do it. Every step is tagged below, so you can see which pillar is carrying which beat.

  1. 01

    Work arrives

    An email lands, an automation runs, or you start a chat with the agent yourself.

  2. 02AI Workforce

    AptiveAI Agents starts a task

    The agent you configured for this job, with the instructions and tool grants it was given.

  3. 03Infrastructure

    It works on its own computer

    An isolated computer with a browser and a desktop — ours, or yours when the data must stay put.

  4. 04AI Workforce

    It acts in your systems

    Reads the mailbox, updates the yard system, files the claim — through the connectors it was granted.

  5. 05

    You watch and steer

    Its screen is live while it works. Correct it in the chat, or take the keyboard yourself.

  6. 06

    The work is done, and written down

    A transcript of every action it took: the conversation kept a year, the tool-call detail 30 days.

Throughput

Work in. Work done.

That path is not a queue of one. Your agents run at the same time, each on its own computer — the trailer check and the invoice sweep do not wait for each other.

01

Connect the systems

We connect the mailbox, the fleet software, the EHR — whatever this job touches.

02

Configure the agent

Instructions, tool grants, and guardrails, written in the builder. No code.

03

It runs

Attended from a chat, or unattended on a schedule — on its own computer either way.

04

Watch, steer, review

Watch its screen while it works and correct it mid-task, then read the transcript of every action.

How a task works, in depth →

Getting Started

Get set up in four steps.

Setup is how you join; the flow above is what it does. There is nothing to install and nothing for your team to build — the first three steps are ours, and in a vertical we already serve they take about a day and a half.

Step 01

We map your systems

One assessment session with the people who do the work today.

We sit with your team and walk the actual job: which software it touches, where the data lives, what gets typed twice, and what goes wrong when someone is on holiday. The output is a short list of candidate agents ranked by how much time each one gives back. Most businesses already know which job this should be. The assessment is mostly about the systems behind it — how we reach them, and what an agent is allowed to do once it is in there.

Step 02

We connect the systems

Existing connectors are ready. A new system takes longer, and we say so.

Connectors are authenticated access to software you already run — business email, fleet management and yard operations, EHR, scheduling and billing, CRM, document stores. Where a system already has a connector, wiring your workspace to it is a day or two. Where it does not, we build one, and we tell you the timeline before you sign. Credentials go into the credential store and are never shown back to anyone, including us. Each agent is granted only the specific tools it needs, not the whole system.

Step 03

We author the first agent

Instructions, tool grants, guardrails, automations.

An agent is a configuration, not a prompt. We write its instructions with you in the two-pane builder — the creator chat on the left turning what you said into instructions, a live test chat on the right so you can try it the same minute. Then the guardrails: which actions it may take on its own, which ones it must ask about first, and what it must never do. Finally the automation, if this job runs unattended — the cadence, the gates that hold a task back, and the rules that skip it when there is nothing to do.

Step 04

Your team takes it over

One or two sessions. Then you watch the first week of tasks.

We train the people who will live with the agent: how to start a task, how to read a transcript, how to watch the live view and take the keyboard when it heads somewhere you did not intend, and how to change the instructions when the process changes. After that the relationship is ongoing rather than finished. External APIs change and we keep the connectors working; new work turns into new agents over the contract; and every quarter we review what your team actually used and what to automate next.

Connectors in depth — the systems we connect →

Architecture

Three layers. One flow.

AptiveAI Agents — the application your team logs into at console.aptiveai.io. Your agent roster, every task and its transcript, your automations, and the list of connected systems. We host it and we run it; there is nothing for you to install.

Computers — the isolated computer each agent works on, with a real browser and a real desktop. Ours by default; on your own hardware when the data is not allowed to leave your infrastructure. One agent per computer, so nothing an agent does can reach another one’s work.

Connectors — authenticated access into the software you already run. Each agent is granted specific tools inside a connected system rather than the whole system, and every call it makes lands in the transcript.

AptiveAI AgentsHosted. You don't run this.
ComputersOne computer per agent.
ConnectorsThe systems you already run.
◄── live view ──►◄── granted tools ──►
Workspaces in depth →

Around the clock

On shift 24 hours a day, so your team is not.

Put an agent on a cadence — hourly, daily, weekdays, weekly, or a cron line of your own — and it runs unattended on its own computer, in your timezone, whether or not anyone is in the building. The trailer check before the yard opens. The order mailbox every hour of the working day. The eligibility checks after the clinic closes. Nobody has to remember it and nobody has to stay late for it, and the people who used to do this work at 6am are free for the work that actually needs a person.

Business hours
Run only inside a window you set, on the days you choose, in the automation’s own timezone. Outside it the firing is held, and the skip is written down.
Skip when idle
Before it starts, the agent checks whether there is anything to work on. Nothing in the queue means no task, and nothing for you to read. “Could not check” is recorded as exactly that, never as “nothing there”.
Asks before it acts
A task an automation started pauses before an irreversible action and waits for a person to answer. On by default; you decide which actions it may take on its own.
No pile-ups, no runaways
If the previous firing is still working, the next one is skipped rather than stacked. After a run of consecutive failures the automation pauses itself instead of retrying into a broken system.

Every firing lands on the automation’s timeline — dispatched, or skipped with the reason — so a month of running is a month you can read back, not a single green light.

Automations in depth →

Ready to see it on your systems?

Bring the job your team keeps meaning to automate. We will show you what an agent doing it actually looks like.