Product

Announcing Aethex PULSE

Announcing Aethex PULSE

Published

•

Written by

Ayooluwa Odemuyiwa

0:00/0:00

6 min Read

Keep Reading

Announcing Aethex PULSE


When an operations team takes on a new case, nobody expects it to be resolved in one phone call. A case gets opened, worked, parked while someone waits on a document, picked up again on a schedule and eventually closed. The case outlives every conversation about it.

Voice agents have mostly been built the other way round. The execution model is the session: context is assembled when the call connects, the agent reasons over it while the call is live, and the state is thrown away when the line drops. That works for single-turn intents. It breaks down for the work enterprises in our markets actually want automated, such as collections, KYC and appointment management. That work runs for days, spans many touchpoints and happens over networks where calls drop.

Today we're announcing PULSE (Persistent Understanding, Loops & Scheduled Execution), the execution layer underneath our voice agents. PULSE moves the unit of execution from the call to the customer.

Four design decisions set it apart:

  1. Built for the latency of a live phone call. Heavy work is fanned out, so the voice agent never has to go quiet.

  2. State per customer, not per assistant. Every customer has one isolated record that every interaction reads and writes.

  3. Loops are business processes, with compliance built in. The rules live in the loop, not in the model.

  4. Triggered by the systems your business already runs. Payments, documents and schedules move the work forward, not just calls.

01 — Built for the latency of a live phone call

Voice has a hard latency budget. A pause much longer than a second reads as a dropped line, and real work like checking a record, verifying an identity or updating a system takes longer than that.

PULSE splits the problem in two. The voice agent owns the conversation and stays on a fast path. When a turn needs real work, it breaks the task into units and fans them out to sub-agents, each with its own context and a narrow set of tools.

They run in parallel while the voice agent keeps the caller engaged, and their results are merged back into the turn as they complete. Tool output and intermediate reasoning stay inside the sub-agents, so the voice agent's context stays small and its responses stay fast.

The voice agent keeps talking. Sub-agents do the slow work in parallel, each with only the tools it needs.

The same design handles the failure that's common on our networks: the dropped call. Because the case lives outside the session, the next call resumes from the last saved state instead of starting over.

02 — State per customer, not per assistant

Most agent memory is built for one assistant serving one user. An enterprise deployment is the opposite: one agent serving hundreds of thousands of customers, each with their own history, obligations and open cases.

In PULSE, state is a structured, per-customer record covering:

  • what was promised

  • what was verified

  • what is still outstanding

  • prior outcomes

  • contact preferences

Every interaction reads from that record when it starts and writes back to it when it ends. Records are isolated by customer, so an agent working one case only ever sees that customer's data.

One record per customer, pulled for each interaction and written back when it ends.

03 — Loops are business processes, with compliance built in

A PULSE loop is a long-running workflow defined as a series of steps, branches and waits, and executed as a durable state machine. The loop engine saves its position after every step, so execution can pause for hours or days and resume exactly where it stopped. A redeploy, a network failure or a customer who doesn't pick up doesn't reset it.

The rules live in the loop, not in the model's judgement.

Contact windows, maximum attempts and escalation paths are declared once and enforced by the runtime on every run. For collections and KYC, where how and when you contact a customer is regulated, that is the difference between a demo and something a compliance team can sign off.

Here is a simplified, illustrative definition of a collections loop:

loop: collections_promise_to_pay
trigger:
  event: call.completed
  when: outcome == "promise_to_pay"

steps:
  - wait_until: state.promise_date + 1d
  - subagent: verify_payment
    tools: [payments.read]
  - branch:
      paid:   { close_case: true }
      unpaid: { schedule_call: { in: 1d, intent: "agree_new_date" } }

guardrails:
  max_attempts: 5
  contact_window: "09:00-18:00 local"
  on_failure: { retry: 3, then

In practice, that loop plays out like this:

Promise → wait → check payment → paid closes the case, unpaid books a call back. The guardrails wrap every step.


04 — Triggered by the systems your business already runs

Session-bound agents only run when a customer calls. PULSE loops can start and resume on events from the enterprise's own systems, such as a payment posting, a document being uploaded or a call ending with a particular outcome, as well as on time-based schedules like "one day after the promised date".

That means the agent responds to what is happening in the business, not just to what the customer happens to say.

A payment that lands at midnight closes the case before the reminder call goes out.

Architecture

The voice agent owns the conversation. PULSE wraps it with four components:

  • Customer state store: the per-customer record

  • Scheduler: time-based triggers

  • Loop engine: durable, resumable workflows

  • Sub-agent orchestrator: fan-out and merge

Sub-agents run inside a hardened sandbox, which is their only path to the live web and to customer systems such as CRMs, core banking, payments and scheduling tools. Access is scoped to the tools each task has been granted, and nothing in the sandbox can reach the host infrastructure.

Session-bound agents vs PULSE


Session-bound agent

Agent on PULSE

Unit of execution

The call

The customer

Latency strategy

Heavy work inline, competing with speech

Fast voice path, heavy work fanned out

State

Ephemeral, rebuilt every call

Persistent per-customer record, isolated by customer

Long-running work

Restarted by a human

Durable loops that resume automatically

Compliance rules

In the prompt

Declared per loop, enforced by the runtime

Triggers

Inbound calls only

Calls, schedules and business-system events

Dropped calls

Case lost

Next call resumes from saved state

Visibility and control

Autonomy only works if the people running it can see what it's doing. PULSE records every state change and loop transition, so for any case a team can see:

  • what the agent knew

  • what it decided

  • which sub-agents ran

  • which actions it took, in order

Built for how our markets work

We build for enterprises in emerging markets, where the processes that matter most are long and fragmented. Collections run in cycles. KYC waits on documents. Networks drop calls, and customers move between numbers and channels.

Those are exactly the points where session-bound agents fail, and exactly what PULSE was designed around.

Getting started

  1. Map the process. Pick a workflow that spans more than one interaction, such as a collections cycle, an onboarding flow or an appointment chain, and define its steps, waits and exit conditions.

  2. Connect the systems. Grant the specific tools each step needs through scoped access to your CRM, payments or scheduling stack, and choose which events should trigger the loop.

  3. Set the guardrails and go live. Define contact windows, attempt limits and escalation paths, then test the loop end to end before switching it on.

PULSE is rolling out across Aethex agents now. To see what it could run for your operations, book a demo.

Listen to article
0:00/0:00

Announcing Aethex PULSE


When an operations team takes on a new case, nobody expects it to be resolved in one phone call. A case gets opened, worked, parked while someone waits on a document, picked up again on a schedule and eventually closed. The case outlives every conversation about it.

Voice agents have mostly been built the other way round. The execution model is the session: context is assembled when the call connects, the agent reasons over it while the call is live, and the state is thrown away when the line drops. That works for single-turn intents. It breaks down for the work enterprises in our markets actually want automated, such as collections, KYC and appointment management. That work runs for days, spans many touchpoints and happens over networks where calls drop.

Today we're announcing PULSE (Persistent Understanding, Loops & Scheduled Execution), the execution layer underneath our voice agents. PULSE moves the unit of execution from the call to the customer.

Four design decisions set it apart:

  1. Built for the latency of a live phone call. Heavy work is fanned out, so the voice agent never has to go quiet.

  2. State per customer, not per assistant. Every customer has one isolated record that every interaction reads and writes.

  3. Loops are business processes, with compliance built in. The rules live in the loop, not in the model.

  4. Triggered by the systems your business already runs. Payments, documents and schedules move the work forward, not just calls.

01 — Built for the latency of a live phone call

Voice has a hard latency budget. A pause much longer than a second reads as a dropped line, and real work like checking a record, verifying an identity or updating a system takes longer than that.

PULSE splits the problem in two. The voice agent owns the conversation and stays on a fast path. When a turn needs real work, it breaks the task into units and fans them out to sub-agents, each with its own context and a narrow set of tools.

They run in parallel while the voice agent keeps the caller engaged, and their results are merged back into the turn as they complete. Tool output and intermediate reasoning stay inside the sub-agents, so the voice agent's context stays small and its responses stay fast.

The voice agent keeps talking. Sub-agents do the slow work in parallel, each with only the tools it needs.

The same design handles the failure that's common on our networks: the dropped call. Because the case lives outside the session, the next call resumes from the last saved state instead of starting over.

02 — State per customer, not per assistant

Most agent memory is built for one assistant serving one user. An enterprise deployment is the opposite: one agent serving hundreds of thousands of customers, each with their own history, obligations and open cases.

In PULSE, state is a structured, per-customer record covering:

  • what was promised

  • what was verified

  • what is still outstanding

  • prior outcomes

  • contact preferences

Every interaction reads from that record when it starts and writes back to it when it ends. Records are isolated by customer, so an agent working one case only ever sees that customer's data.

One record per customer, pulled for each interaction and written back when it ends.

03 — Loops are business processes, with compliance built in

A PULSE loop is a long-running workflow defined as a series of steps, branches and waits, and executed as a durable state machine. The loop engine saves its position after every step, so execution can pause for hours or days and resume exactly where it stopped. A redeploy, a network failure or a customer who doesn't pick up doesn't reset it.

The rules live in the loop, not in the model's judgement.

Contact windows, maximum attempts and escalation paths are declared once and enforced by the runtime on every run. For collections and KYC, where how and when you contact a customer is regulated, that is the difference between a demo and something a compliance team can sign off.

Here is a simplified, illustrative definition of a collections loop:

loop: collections_promise_to_pay
trigger:
  event: call.completed
  when: outcome == "promise_to_pay"

steps:
  - wait_until: state.promise_date + 1d
  - subagent: verify_payment
    tools: [payments.read]
  - branch:
      paid:   { close_case: true }
      unpaid: { schedule_call: { in: 1d, intent: "agree_new_date" } }

guardrails:
  max_attempts: 5
  contact_window: "09:00-18:00 local"
  on_failure: { retry: 3, then

In practice, that loop plays out like this:

Promise → wait → check payment → paid closes the case, unpaid books a call back. The guardrails wrap every step.


04 — Triggered by the systems your business already runs

Session-bound agents only run when a customer calls. PULSE loops can start and resume on events from the enterprise's own systems, such as a payment posting, a document being uploaded or a call ending with a particular outcome, as well as on time-based schedules like "one day after the promised date".

That means the agent responds to what is happening in the business, not just to what the customer happens to say.

A payment that lands at midnight closes the case before the reminder call goes out.

Architecture

The voice agent owns the conversation. PULSE wraps it with four components:

  • Customer state store: the per-customer record

  • Scheduler: time-based triggers

  • Loop engine: durable, resumable workflows

  • Sub-agent orchestrator: fan-out and merge

Sub-agents run inside a hardened sandbox, which is their only path to the live web and to customer systems such as CRMs, core banking, payments and scheduling tools. Access is scoped to the tools each task has been granted, and nothing in the sandbox can reach the host infrastructure.

Session-bound agents vs PULSE


Session-bound agent

Agent on PULSE

Unit of execution

The call

The customer

Latency strategy

Heavy work inline, competing with speech

Fast voice path, heavy work fanned out

State

Ephemeral, rebuilt every call

Persistent per-customer record, isolated by customer

Long-running work

Restarted by a human

Durable loops that resume automatically

Compliance rules

In the prompt

Declared per loop, enforced by the runtime

Triggers

Inbound calls only

Calls, schedules and business-system events

Dropped calls

Case lost

Next call resumes from saved state

Visibility and control

Autonomy only works if the people running it can see what it's doing. PULSE records every state change and loop transition, so for any case a team can see:

  • what the agent knew

  • what it decided

  • which sub-agents ran

  • which actions it took, in order

Built for how our markets work

We build for enterprises in emerging markets, where the processes that matter most are long and fragmented. Collections run in cycles. KYC waits on documents. Networks drop calls, and customers move between numbers and channels.

Those are exactly the points where session-bound agents fail, and exactly what PULSE was designed around.

Getting started

  1. Map the process. Pick a workflow that spans more than one interaction, such as a collections cycle, an onboarding flow or an appointment chain, and define its steps, waits and exit conditions.

  2. Connect the systems. Grant the specific tools each step needs through scoped access to your CRM, payments or scheduling stack, and choose which events should trigger the loop.

  3. Set the guardrails and go live. Define contact windows, attempt limits and escalation paths, then test the loop end to end before switching it on.

PULSE is rolling out across Aethex agents now. To see what it could run for your operations, book a demo.

Announcing Aethex PULSE


When an operations team takes on a new case, nobody expects it to be resolved in one phone call. A case gets opened, worked, parked while someone waits on a document, picked up again on a schedule and eventually closed. The case outlives every conversation about it.

Voice agents have mostly been built the other way round. The execution model is the session: context is assembled when the call connects, the agent reasons over it while the call is live, and the state is thrown away when the line drops. That works for single-turn intents. It breaks down for the work enterprises in our markets actually want automated, such as collections, KYC and appointment management. That work runs for days, spans many touchpoints and happens over networks where calls drop.

Today we're announcing PULSE (Persistent Understanding, Loops & Scheduled Execution), the execution layer underneath our voice agents. PULSE moves the unit of execution from the call to the customer.

Four design decisions set it apart:

  1. Built for the latency of a live phone call. Heavy work is fanned out, so the voice agent never has to go quiet.

  2. State per customer, not per assistant. Every customer has one isolated record that every interaction reads and writes.

  3. Loops are business processes, with compliance built in. The rules live in the loop, not in the model.

  4. Triggered by the systems your business already runs. Payments, documents and schedules move the work forward, not just calls.

01 — Built for the latency of a live phone call

Voice has a hard latency budget. A pause much longer than a second reads as a dropped line, and real work like checking a record, verifying an identity or updating a system takes longer than that.

PULSE splits the problem in two. The voice agent owns the conversation and stays on a fast path. When a turn needs real work, it breaks the task into units and fans them out to sub-agents, each with its own context and a narrow set of tools.

They run in parallel while the voice agent keeps the caller engaged, and their results are merged back into the turn as they complete. Tool output and intermediate reasoning stay inside the sub-agents, so the voice agent's context stays small and its responses stay fast.

The voice agent keeps talking. Sub-agents do the slow work in parallel, each with only the tools it needs.

The same design handles the failure that's common on our networks: the dropped call. Because the case lives outside the session, the next call resumes from the last saved state instead of starting over.

02 — State per customer, not per assistant

Most agent memory is built for one assistant serving one user. An enterprise deployment is the opposite: one agent serving hundreds of thousands of customers, each with their own history, obligations and open cases.

In PULSE, state is a structured, per-customer record covering:

  • what was promised

  • what was verified

  • what is still outstanding

  • prior outcomes

  • contact preferences

Every interaction reads from that record when it starts and writes back to it when it ends. Records are isolated by customer, so an agent working one case only ever sees that customer's data.

One record per customer, pulled for each interaction and written back when it ends.

03 — Loops are business processes, with compliance built in

A PULSE loop is a long-running workflow defined as a series of steps, branches and waits, and executed as a durable state machine. The loop engine saves its position after every step, so execution can pause for hours or days and resume exactly where it stopped. A redeploy, a network failure or a customer who doesn't pick up doesn't reset it.

The rules live in the loop, not in the model's judgement.

Contact windows, maximum attempts and escalation paths are declared once and enforced by the runtime on every run. For collections and KYC, where how and when you contact a customer is regulated, that is the difference between a demo and something a compliance team can sign off.

Here is a simplified, illustrative definition of a collections loop:

loop: collections_promise_to_pay
trigger:
  event: call.completed
  when: outcome == "promise_to_pay"

steps:
  - wait_until: state.promise_date + 1d
  - subagent: verify_payment
    tools: [payments.read]
  - branch:
      paid:   { close_case: true }
      unpaid: { schedule_call: { in: 1d, intent: "agree_new_date" } }

guardrails:
  max_attempts: 5
  contact_window: "09:00-18:00 local"
  on_failure: { retry: 3, then

In practice, that loop plays out like this:

Promise → wait → check payment → paid closes the case, unpaid books a call back. The guardrails wrap every step.


04 — Triggered by the systems your business already runs

Session-bound agents only run when a customer calls. PULSE loops can start and resume on events from the enterprise's own systems, such as a payment posting, a document being uploaded or a call ending with a particular outcome, as well as on time-based schedules like "one day after the promised date".

That means the agent responds to what is happening in the business, not just to what the customer happens to say.

A payment that lands at midnight closes the case before the reminder call goes out.

Architecture

The voice agent owns the conversation. PULSE wraps it with four components:

  • Customer state store: the per-customer record

  • Scheduler: time-based triggers

  • Loop engine: durable, resumable workflows

  • Sub-agent orchestrator: fan-out and merge

Sub-agents run inside a hardened sandbox, which is their only path to the live web and to customer systems such as CRMs, core banking, payments and scheduling tools. Access is scoped to the tools each task has been granted, and nothing in the sandbox can reach the host infrastructure.

Session-bound agents vs PULSE


Session-bound agent

Agent on PULSE

Unit of execution

The call

The customer

Latency strategy

Heavy work inline, competing with speech

Fast voice path, heavy work fanned out

State

Ephemeral, rebuilt every call

Persistent per-customer record, isolated by customer

Long-running work

Restarted by a human

Durable loops that resume automatically

Compliance rules

In the prompt

Declared per loop, enforced by the runtime

Triggers

Inbound calls only

Calls, schedules and business-system events

Dropped calls

Case lost

Next call resumes from saved state

Visibility and control

Autonomy only works if the people running it can see what it's doing. PULSE records every state change and loop transition, so for any case a team can see:

  • what the agent knew

  • what it decided

  • which sub-agents ran

  • which actions it took, in order

Built for how our markets work

We build for enterprises in emerging markets, where the processes that matter most are long and fragmented. Collections run in cycles. KYC waits on documents. Networks drop calls, and customers move between numbers and channels.

Those are exactly the points where session-bound agents fail, and exactly what PULSE was designed around.

Getting started

  1. Map the process. Pick a workflow that spans more than one interaction, such as a collections cycle, an onboarding flow or an appointment chain, and define its steps, waits and exit conditions.

  2. Connect the systems. Grant the specific tools each step needs through scoped access to your CRM, payments or scheduling stack, and choose which events should trigger the loop.

  3. Set the guardrails and go live. Define contact windows, attempt limits and escalation paths, then test the loop end to end before switching it on.

PULSE is rolling out across Aethex agents now. To see what it could run for your operations, book a demo.

Related Articles

Related Articles

The voice AI stack for emerging markets.

See agents in production, configured for your use case, your market, your systems.

Screenshot of the Aethex logo

© 2026, AethexAI Inc.

The voice AI stack for emerging markets.

See agents in production, configured for your use case, your market, your systems.

Screenshot of the Aethex logo

© 2026, AethexAI Inc.

The voice AI stack for emerging markets.

See agents in production, configured for your use case, your market, your systems.