Goal-Driven AI Calls: When the Assistant Actually Runs the Conversation

Reactive Isn't Enough Anymore

Most AI phone agents are reactive. They pick up the call, wait for the caller to say something, and respond. That works well for inbound support — the caller has a question, the AI answers. It falls apart the moment the AI is the one with the agenda.

If your assistant is calling a restaurant to book a table, a doctor's office to confirm a prescription, or a vendor to collect a delivery window, the AI cannot sit back and wait. It needs to drive. It needs to know what information is missing, ask for it, handle the detours, and hang up the second the job is done.

That's what active-mode calls are for. Starting today, any hiroi agent can place an outbound call with a specific goal attached — a list of fields to fill, a reason for calling, and a time budget. The AI owns the conversation end-to-end.

How Goal-Driven Calls Work

You describe the goal. The AI executes it. Everything else is mechanics.

The Goal

A goal has three parts: a natural-language description (why you're calling), a list of schema fields (what you need to learn), and a time budget (how long to try before giving up). Here's what that looks like in practice:

goal_description: "Confirm that the prescription for Alex Morgan is ready
                   for pickup at the Walgreens on Maple Street."
fields:
  - ready (boolean)
  - pickup_hours (string)
  - requires_signature (boolean)
time_budget_s: 120

The AI opens the call, introduces itself, and starts filling fields. It doesn't read them off like a form — it weaves them into the conversation the way a person would. "Hi, I'm calling on behalf of Alex Morgan to check on a prescription. Is that ready for pickup, and what are your hours today?"

The Turn Policy

Under the hood, a decision layer called TurnPolicy routes every speech event through three possible modes:

• Reactive — the AI responds to what the caller says. This is the old behavior, unchanged for inbound support calls.
• Active — the AI drives. After the other party speaks, the policy checks which schema fields are still unfilled, what just got filled, and what the next logical ask is.
• Passive — the AI listens silently, speaking only when addressed or when the topic touches the goal. This matters for three-way calls where your assistant is an observer, not the primary speaker.

Every active call also carries an update_schema tool. When the caller answers a question, the AI calls the tool with the field name and the extracted value. Once the last required field is filled, the AI fires a polite close and hangs up — often in the same turn.

The Time Budget

Active calls don't run forever. If the other party can't help, or keeps routing to voicemail, or just talks past the question, the time budget ends the call gracefully. The post-call log captures what was filled, what was missed, and why — so you know whether to retry, route to a human, or accept the partial result.

Why This Changes Outbound Automation

Most "AI calling" platforms give you a script tree. You draw the conversation in advance, branch on every possible answer, and hope the caller stays inside the tree. They never do. People mumble. They put the phone down. They ask a question you didn't anticipate. Script trees shatter on contact with reality.

Goal-driven calls don't care about branches. The AI is trying to fill a schema. Whatever the caller says, the policy asks: "Did that get us closer to the goal? What's still missing?" The conversation can meander, come back, clarify — the AI just keeps quietly filling the form in its head.

This is the difference between "automation" and "delegation." Scripts automate a sequence of steps. Goals delegate an outcome.

Real Examples

Appointment Confirmations

A medical practice used to have staff call fifty patients a day to confirm next-day appointments. Now the assistant places the calls. Goal: confirm the appointment or reschedule. Fields: confirmed (boolean), reschedule_requested (boolean), preferred_window (string). The assistant handles the easy confirmations in under a minute each and kicks the reschedules back to a human.

Vendor Check-Ins

A logistics team needed to ping twenty suppliers for weekly delivery windows. Goal: get the next shipment date and tracking number. The AI makes the calls during business hours, fills the schema, and pushes the results into the team's tracking sheet via an action.

Personal Assistant Errands

On the PA side, users can dispatch their assistant to make small phone calls on their behalf — checking on a restaurant reservation, asking a repair shop for a quote, confirming an event RSVP. The goal is described in plain English; the PA translates it into a schema and runs the call.

In every case, the human defines the outcome. The AI handles the call.

What's Under the Hood

For anyone curious about the architecture:

• Goals and fields live in pa_goals.py as first-class primitives — Goal, SchemaField, Participant, OpenLoop.
• Call sessions carry mode, channel_context, goal, and participants through Redis so the AI sees the same state on every turn, even when the call spans multiple worker processes.
• The system prompt gets a runtime_context block that tells the agent which channel it's on, what the current goal is, which fields are unfilled, and any per-turn overlay the caller provided.
• A 46-test suite covers the decision matrix, the schema fill mechanics, the tool definition, and the session serialization roundtrip — active-mode calls are treated as a first-class pipeline, not a retrofit.

The update_schema tool is constrained to the fields defined in the goal — the AI can't make up new fields mid-call. The enum boundary keeps the call focused on the job it was dispatched to do.

How to Use It

Active-mode calls are exposed through a new endpoint:

POST /api/outbound/active-call/<site_id>
{
  "phone": "+15551234567",
  "goal_description": "Confirm the bakery has gluten-free bread in stock.",
  "fields": [
    {"name": "in_stock", "type": "boolean"},
    {"name": "pickup_hours", "type": "string"}
  ],
  "time_budget_s": 90,
  "contact_name": "The Bread Shop"
}

Your agent — same voice, same persona, same knowledge base — picks up the goal and runs the call. When it finishes, the response includes the filled schema, the call transcript, and whether the goal was reached.

If you're already running outbound campaigns on hiroi, active-mode is a natural next step. Campaigns handle volume; active calls handle outcomes.

One Assistant, Real Outcomes

The chat widget, inbound phone lines, outbound campaigns, and now goal-driven calls — all the same agent. Your assistant already knows your business. Now it can pick up the phone and actually get something done for you.

Configure an active call from your dashboard or hit the endpoint directly. Give your AI a job. Let it finish.