Claims and pre-authorisation follow-up

Claims that don’t wait on a missing form.

A claim or pre-authorisation comes in incomplete. A loop reads what is missing from your claims system, asks the member for exactly that, and records every contact. When the documents land, your system starts the next step.
The problem

Why claims stall

“We wait on paperwork, not decisions.”

Most delays are a missing invoice or referral.

“Members don’t know what we need.”

A generic letter gets a generic response, or none.

“Nobody owns the chase.”

Follow-up falls between the claims team and the call centre.
How the loop works

How the follow-up loop runs

  1. An incomplete claim starts it. Your claims system starts the loop with the claim and the member.
  2. It reads what is missing. The loop asks your claims API which documents are outstanding.
  3. It asks for exactly that. A text that names each missing document and links to your upload page. A call if the member prefers one.
  4. Every contact on record. What was asked, when and how is saved to the claim.
  5. The next run moves it on. When documents arrive, your system starts the next loop, with the member’s memory carrying the context.
missing-documents.tsTypeScript
interface Claim { claimId: string; memberId: string; phone: string }

export class HealthLoop extends Workflow {
  async run(event: HealthEvent<Claim>, step: HealthStep) {
    const { claimId, memberId, phone } = event.body;

    const missing = await step.do("Read missing documents", async () => {
      const url = `${this.env.CLAIMS_API}/claims/${claimId}/missing`;
      const res = await fetch(url);
      return (await res.json()) as string[];
    });

    if (missing.length === 0) return { claimId, status: "complete" };

    await step.do("Ask the member", ({ ctx }) =>
      ctx.SMS.send({
        to: phone,
        content:
          `To finish claim ${claimId} we need: ${missing.join(", ")}. ` +
          `Upload them at ${this.env.UPLOAD_URL}/${claimId}`,
      }),
    );

    await step.do("Record the request", async ({ ctx }) => {
      const member = await ctx.USER.getUser({ id: memberId });
      await member.remember(`Asked for ${missing.join(", ")} on claim ${claimId}`);
    });

    return { claimId, status: "waiting", missing };
  }
}
Channels and integrations

What the loop works with

SMS. One message or up to 500 at once, with opt-out checks and timed delivery.
Phone calls. Outbound calls to a phone number, or a browser call from your app. Each call ends with a transcript and a summary.
Chat. Agent loops answer in your own app or site, from documents you upload, and can start other loops mid-conversation.
Your own systems. Loops call your endpoints to read data and send results back. Your systems start loops with one authenticated API call.
Data and compliance

How data is handled

Your own data plane. Each organisation’s loops, runs, members and keys live in that organisation’s own store, apart from every other customer.
Keys you control. An API key only reaches loops in the organisation that made it, and you can revoke it at any time. Secrets are encrypted and only admins can see them.
A record of every run. The trigger, each step and its result, every tool call, every log line and every error are kept for your team to review.
FAQ

Questions

Can Health Loops follow up on claims and pre-authorisations?

Yes. A loop reads what a claim or pre-authorisation is missing from your claims system, asks the member for exactly those documents by text or call, records each contact, and your system starts the next step when they arrive.

Does the loop approve or decline claims?

It applies only the rules you write into it. Approvals and declines stay with your claims rules and your team.

Where do members upload documents?

To your own upload page or app. The loop sends the link and your claims system tells it what has arrived.

See this loop run on your own journey.