The call is one step, not the task: how Layerup's proprietary voice AI stack runs long-horizon agents from first ring to write-back

Voice AI gets evaluated on the call. How natural does it sound, how fast does it respond, how gracefully does it handle being interrupted. Those questions matter, and Layerup's stack is built to answer them well. But they are the wrong place to stop, because a phone call is almost never the task. The task is the promise to pay recorded against the loan, the claim opened and routed, the note posted in the servicing system, the confirmation text that goes out, the callback that happens on the day the customer asked for. A voice agent that sounds excellent and then hangs up has completed roughly a third of the work.

Layerup's voice AI stack is proprietary for a specific reason: we needed the conversation to be one step inside a longer run, not the whole run. The same system that holds the conversation in real time also has to verify identity against your records, take actions in your core systems while the customer is still on the line, keep working after the hang-up, remember the conversation next week, and hand the outcome to the long-horizon agent that owns the file. Off-the-shelf voice platforms are built to end at the call. Ours is built to finish the task.

This piece walks through the stack layer by layer — the real-time loop, the action layer, the post-call pipeline, and the multi-day orchestration on top — and then follows one delinquent account end to end to show how the pieces compose.

Why most voice agents stop at the hang-up

The standard voice agent architecture is a loop: speech in, transcript to a language model, text to speech out, repeat until someone hangs up. Wrapped around that loop is a transcript, maybe a summary, and a webhook. Everything that should happen next — updating the account, scheduling the callback, posting the note, deciding when to call again — is someone else's problem. Usually that someone is a human reading a summary, or a brittle integration that fires once and hopes.

This is the one-shot pattern applied to voice. One call in, one transcript out, no memory of the last conversation, no obligation to finish. It produces demos that sound remarkable and operations that still depend on people to close the loop. The metric that suffers is the one that matters: how many accounts, claims, or cases actually reached resolution without a human touching them.

What 'proprietary stack' means, and what it does not

Layerup did not train a speech recognizer from scratch, and we would be suspicious of a vendor who claimed that was the differentiator. Speech recognition, speech synthesis, and language models are the swappable layer of our platform: we use the best model per language and per task, and we replace models as better ones ship. What is proprietary is everything around them — the harness that turns models into an agent that finishes work.

• The conversation loop. Phase-based prompting, gated tools, parallel tool execution, barge-in handling, filler words, hold, voicemail detection, and mid-call language switching, all coordinated around a single per-call state machine.
• The action layer. A provider model that binds each call to your loan, customer, claim, payment, and escalation systems, and exposes only the tools those systems make available.
• The post-call pipeline. Recording, full transcription, summary, sentiment, tagging, payment and compliance analysis, memory extraction, note posting, outreach scheduling, and handoff to the agent that owns the file.
• The orchestration layer. Campaign-driven dialing with predicates, time windows, frequency limits, and compliance rules, plus cross-channel follow-ups that carry the conversation across text, email, and chat.

Each layer is exercised by the others. That is the point of owning them together: the post-call pipeline knows which tools fired during the call, the dialer knows what the last call concluded, and the next call starts with the memory of both.

Layer one: a real-time loop built for negotiation, not scripts

A negotiation is a conversation where the customer pushes back, changes their mind mid-sentence, and expects the other side to keep up. The live loop is engineered for that.

The loop is built for latency. The model's reply is handed to the voice one sentence at a time, as soon as each sentence closes, so the agent starts speaking before it has finished thinking — with one guard: a period followed by a digit is not a sentence end, so a dollar amount or an account number is never split across two utterances. If the model needs more than about a second and a half to begin, the agent may use a natural filler so the line does not go dead, and the threshold adapts as the conversation lengthens.

Interruptions are handled, not tolerated. When the customer cuts in, the agent's queued speech is discarded immediately and the transcript is annotated to record exactly where the customer stopped listening. The model's next turn is grounded in what the customer actually heard, not in what the agent intended to say.

The conversation moves through phases. Identification establishes who is on the line — by phone number, account number, or a demographic lookup against your records. Verification confirms it with the datapoints you require, and the system tracks which have been satisfied so a customer is never asked twice for the same one. Only then does the objective phase open. Tools are gated by phase: a payment tool does not exist, as far as the model is concerned, until verification is complete.

Within the objective phase, the agent negotiates inside a fence you define. For a collections call, that fence is the objective, the call rules, the account information, the payment instructions, and the post-verification call structure your team configures — delivered in whichever language the customer prefers. The agent can hold a real back-and-forth — partial amounts, alternative dates, a different payment method, a callback — and it can commit the outcome in the moment. It also knows the shape of a non-outcome: a promise to pay 'when I get paid' is not a specific date, and the tool that records promises refuses to accept it and routes the customer to a human instead.

• Retrieval on every substantive turn. Company documents and approved answers are retrieved against what the customer just said and injected into the prompt, with retrieval skipped on trivial acknowledgements to protect latency.
• Mid-call language switching. The customer asks for Spanish and the agent's voice and language switch together, with a brief reintroduction so the change is never jarring.
• Keypad input for sensitive data. Card numbers and identifiers can be entered by keypad; the stack logs only that digits were received, never the digits themselves.
• Hold, voicemail, and screeners. The agent can place the customer on hold with hold audio, detect a voicemail and leave a message, and recognize an automated call screener and state its name and purpose to get through.
• Human escalation as a tool. Escalation to a live agent — by phone, Slack, or a support desk — is a tool the agent can call with a reason, not a failure mode.

Layer two: actions in your systems while the customer is still on the line

A voice agent that says 'I've recorded that for you' had better have recorded it. Layerup's action layer binds every call to the systems the company actually runs through a provider model. When a call starts, the stack resolves — per company, and per use case within the company — which loan or policy system, which customer record, which claims system, which payment processor, which escalation path, and which document store the agent should use. Tools are loaded from those providers. A lender that processes payments through one processor and a lender that uses a different one run the same agent, with different tools underneath.

The actions themselves run during the call, against the system of record. The promise to pay is written with the amount, date, and callback preference the customer agreed to. The card payment is submitted and the receipt is sent. The callback is scheduled against the account. The confirmation text goes out. The claim is opened and its number read back to the caller. Each is a typed tool call with its result recorded in the conversation and in the audit trail.

Warm transfer works the way a good receptionist does. The agent places the customer on hold, dials the human, navigates the receiving line's screener if there is one, and briefs the human with a summary of the conversation so far — deliberately excluding the verification details the customer provided. Then it bridges the two. If no one answers within the configured window, it tries the next number on the list, and if the list is exhausted it comes back to the customer with a plan rather than dead air.

Layer three: the sixty seconds after the hang-up

When the customer hangs up, the run does not end; it changes mode. The stack fetches the call recording, stores it, and produces a full transcript of the recording so the record of the conversation is complete. From there a pipeline runs against the transcript.

1. Summary, sentiment, and tags. A summary of the call, a sentiment trajectory, and a classification against the tag taxonomy your team defines — each tag carrying its own criteria and scenarios, and optionally a flag that the account should be called back.
2. Evaluation and compliance. The transcript is graded against the evaluation questions configured for that company and use case, and against the compliance control packages enabled for it. Results are stored alongside the call in the same governance records the platform's other agents write to, and guardrails are checked on the full transcript.
3. Outcome extraction. Whether a promise to pay was made and whether cash was collected are extracted from the transcript independently of what the agent believed happened, and stored next to the tool calls that actually fired.
4. System-of-record write-back. For a collections call, a concise note in the format your servicing system expects — including the promise-to-pay date — is generated and posted against the account. Support conversations update the case with category, priority, and status.
5. Next outreach. If the call's tags indicate a callback, the next outreach time is computed from the account's history and your scheduling rules, then written to the account so the dialer picks it up.
6. Memory. The call is distilled into a summary and a set of durable facts about the customer — how they prefer to be addressed, what they said about their situation, what was agreed — and stored for the next conversation.
7. Handoff. Where the call belongs to a longer file, the transcript, summary, and tool calls are handed to the agent that owns it. A claim intake call, for example, hands off for classification, coverage assessment, fraud indicators, a document checklist, and a plan for the rest of the claim.
8. Notification and translation. The team is notified that the call is complete with a link to the record, and if the call was conducted in another language, an English transcript is produced alongside the original.

None of these steps is exotic on its own. The point is that all of them happen automatically, for every call, in the same pipeline that knows what the agent did during the call. This is where a voice agent stops being a transcript generator and becomes a step in a run.

Layer four: the run spans days, and the agent remembers

Most resolutions do not happen in one call. The customer asks for a callback on Friday. The document arrives Tuesday. The promise to pay comes due. A long-horizon voice agent has to carry the thread across those gaps, and that is the job of the orchestration layer.

Outbound work is driven by campaigns rather than lists. A campaign defines who qualifies — predicates on days past due, balance, promise date, status, portfolio — when calls are allowed, in which time zone, on which days, how often a customer may be contacted per day and per week and with what minimum gap, and which compliance checks apply: consent to be called, bankruptcy flags, Sundays, holidays. Accounts flow in and out of campaigns as their state changes. An account that cured last night is not in this morning's queue, and nobody has to tell the dialer.

Continuity comes from memory and from the outcome of the last call. Before the agent speaks, it loads prior call summaries and the durable facts extracted from earlier conversations. The agent calling on Friday knows what was agreed on Monday, and says so. The next outreach time computed after Monday's call is what put Friday's call in the queue in the first place.

The thread is not confined to the phone. The same agent that took the call sends the confirmation text, answers the reply, and, on channels where the customer goes quiet — text, email, chat, messenger — follows up after a configured delay, up to a configured number of times, in the context of the conversation so far. If the customer stays silent after the final nudge, the case is resolved and the record says why. Threads that a human has taken over are left alone.

One delinquent account, first ring to resolution

Consider a consumer loan thirty-one days past due, held by a lender whose collections campaign qualifies accounts between thirty and sixty days late, calls between nine and seven in the account's time zone, caps contact at one call a day, and excludes anyone who has not consented to automated calls or who carries a bankruptcy flag.

1. Monday, 10:14 a.m. The campaign selects the account. The stack picks an outbound number with capacity left for the day, loads the lender's loan, customer, and payment providers, and dials. The customer answers. The agent identifies the account by phone number, verifies the customer with date of birth and ZIP code, and opens the collections phase.
2. Monday, 10:16 a.m. The customer cannot pay the full past-due amount. The agent negotiates inside the lender's rules: it offers to split the amount, the customer counters with Friday, the agent asks for a specific figure and date and whether they want a reminder call. The customer commits to a specific amount on Friday with a morning callback. The agent records the promise to pay against the loan and sends a confirmation text while the customer is still on the line.
3. Monday, 10:18 a.m. The customer hangs up. The recording is stored and fully transcribed. Summary, sentiment, and tags are generated; the lender's evaluation questions and compliance controls are graded; the promise to pay is confirmed by independent analysis; a note with the promise date is posted to the loan servicing system; memory records that the customer prefers morning calls and mentioned a new job starting next month. The team's channel gets a notification with a link to the record.
4. Friday, 9:05 a.m. The promise date arrives and the account re-enters the queue for the reminder call the customer asked for. The agent opens with the context of Monday's conversation, confirms the customer is ready, retrieves the stored payment methods, takes the payment on the card the customer chooses, and sends the receipt. After the hang-up, the pipeline posts the payment note, tags the call as paid, and records the memory. The account no longer matches the campaign's predicates and drops out of the queue.
5. Human touches: none. Everything the collector would have done — the calls, the negotiation, the notes, the reminder, the payment, the follow-through — happened inside one run. The collections lead sees the full record, the recordings, the compliance grades, and the outcome in the dashboard.

Change the domain and the shape holds. A claims intake call opens the claim, verifies coverage, hands off to the claims agent for classification and a document checklist, then chases the missing photos by text and answers the status call a week later from the live file. A billing call verifies the posting, prepares the correction, and confirms it in the same conversation.

Governance is in the loop, not bolted on

A system that negotiates and takes payments on your behalf has to be governable at the level of each decision, and the voice stack was built with that as a constraint rather than a feature.

• Every model call — live turns and post-call analysis alike — goes through a gateway under a purpose alias and is traced per call, so any decision can be reconstructed with the exact prompt, context, and model that produced it.
• Tools are gated three ways: by conversation phase, by the providers configured for the company, and by feature flags your team controls. The model cannot call what is not exposed.
• Verification details are excluded from agent briefings, keypad digits are never logged, and prompt variants under A/B test are recorded against each call so results are attributable.
• Evaluation questions, compliance controls, tags, and guardrails are configured by your team per use case and graded automatically on every call, writing to the same governance records as the platform's other agents.
• Escalation to a human is always one tool call away, and once a human owns a thread, the automation steps back.

What to ask a voice AI vendor

1. Show me what happens in the sixty seconds after the customer hangs up, without a human or a third-party automation tool in the loop.
2. Show me a promise to pay recorded in the servicing system during the call, and the note posted afterward, from a real deployment.
3. Show me the agent calling the same customer a second time. What does it remember, and where did that memory come from?
4. Show me the tools the model can call before identity verification is complete. The right answer is none that touch money or records.
5. Show me a warm transfer end to end, including what the receiving agent hears before the customer is bridged.
6. Show me how outbound dialing decides who to call, when, and how often, and where consent and bankruptcy flags are enforced.
7. Show me the compliance grades and evaluation results for last week's calls, and how the criteria are configured.

The headline

A voice agent should be judged the way you would judge the person it replaces: not by how pleasant they sound on the phone, but by whether the work is done when they put the phone down. Layerup's voice AI stack is proprietary because that standard required it. The real-time loop is built for negotiation, the action layer executes in your systems during the call, the post-call pipeline finishes the paperwork, and the orchestration layer carries the run across days and channels with memory intact. The call is one step. The agent finishes the task.