Juliet

When a critical alert fires, Juliet calls a human, captures a spoken acknowledgment, and escalates up an on-call chain until someone confirms—closing the loop over the phone, with every call logged.

Comment

Inspiration

The athletic trainer is on the field with a squad; the team physician is between patients. A red flag fires on the readiness board — an athlete or operator at elevated injury or overload risk — and it lands on a screen no one is looking at. Someone has to reach that person and confirm they've got it. Dashboards get missed. Chat gets missed. There's no closed loop and no proof the alert landed. That gap isn't a dashboard problem — it's phone work, and CALL-E made us realize the phone is the "act" in "flag → act."

What it does

Juliet — our executive-assistant agent — becomes the voice of the readiness engine. When a RED flag fires, she places a real phone call through CALL-E, delivers the flag in plain, non-diagnostic language, captures a structured verbal acknowledgment, and — if no one confirms — escalates up a role-based on-call chain (trainer → team physician → …) until someone acknowledges, logging every attempt with a timestamp. "System flags. You decide" — now closed-loop, over the phone. We packaged the pattern as a reusable critical-alert-escalation skill: give it an alert, an ordered contact chain, and an acknowledgment schema, and it calls until someone confirms. The guardrails aren't just described — they're enforced in code and measured: in a re-runnable safety eval, 0 calls landed to non-allowlisted numbers across 24 adversarial attempts, with AI disclosure, non-diagnostic language, and fail-toward-escalation all at 100%.

How we built it

Each responder is called through CALL-E's full lifecycle — plan_call → run_call → get_call_run — via the CALL-E CLI and its remote MCP tools. A Strands Agents (TypeScript) agent reasoning with Claude (Amazon Bedrock) orchestrates the chain; Supabase (Postgres) holds the readiness flags, the escalation contact chain, and structured call logs; a React Command Center shows the Readiness panel and Recent Calls. Everything runs through a single guarded place_call wrapper — the raw CALL-E MCP tools are never exposed to the model — that enforces the allowlist and the AI disclosure on every call. The escalation logic reads CALL-E's structured outcome (task_completed + confidence + evidence + summary) and, on anything short of a clear acknowledgment, advances the chain rather than closing the alert — "fail toward escalation."

Challenges we ran into

  • CALL-E dials from rotating caller IDs, so call-screening auto-declines legitimate calls — and allowlisting your own number doesn't help, because the block is on the recipient's device. This one took a while to diagnose.
  • The MCP result is double-wrapped (content[0].text as a JSON string), so a naive field extractor misses the payload.
  • Multi-line call goals broke shell arg-passing on Windows; we fixed it by spawning the CLI's JS entry directly with Node, no shell.
  • run_call returns while the call is still PREPARING, so our first polling window expired before the call connected — the terminal webhook is the better path.

(We wrote all of this up as a separate Most Valuable Feedback report for the CALL-E team.)

Accomplishments that we're proud of

  • A safety number you can re-run. We built a re-runnable guardrail eval (dry-run, no billable calls) that asserts against the real place_call path — not a description. Across the battery: 0 calls to non-allowlisted numbers across 24 adversarial attempts (100% blocked), AI disclosure on 100% of call goals, non-diagnostic language on 100%, and fail-toward-escalation correct on 100% of non-acknowledgments. Run it: npm run eval:guardrails.
  • Both paths demonstrated with real calls, in a single run: the trainer isn't reached → Juliet escalates → the physician answers and acknowledges → the flag closes, logged. And the unacknowledged path (chain exhausts → urgent human hand-off) works too.
  • Safety is architectural, not cosmetic — AI disclosure and non-diagnostic language on every call, allowlist-only, a single guarded entry point the model can't dial around, and every attempt logged and visible.
  • It's a reusable community skill, not a one-off demo.

What we learned

  • "Fail toward escalation" is the right posture for a safety loop — ambiguity should advance the chain, never silently close the alert. CALL-E's confidence signal makes that call clean.
  • The spoken script matters as much as the code: disclosure + non-diagnostic framing + an explicit "if you can't take it, I'll escalate" offer, delivered live, is what makes an AI call responsible.
  • CALL-E's structured outcome maps cleanly to an acknowledgment decision without a bespoke result schema.

What's next for the Readiness Line?

Wire it to live readiness flags (beyond demo triggers); richer escalation policies (time windows, on-call rotations, quiet hours); capture the responder's chosen action, not just acknowledgment; add inbound callbacks; and harden the critical-alert-escalation skill so any ops, incident-response, or safety team can adopt it.

Built With

Share this project:

Updates