Gov OS

When an AI agent auto-authorizes a government action, GovOS calls the real accountable official to confirm or override it live.

Comment

Inspiration

When a real emergency hits a city, a fire, a flood, a building collapse, the government response can't wait for someone to open a dashboard and click "approve." But autonomous systems that skip human approval entirely create a different problem: someone real is still accountable for what gets authorized in their name, and a push notification they might never see doesn't close that gap.

We'd already built GovOS for a separate purpose — a Strands Agents-based system where autonomous agents run Delhi's real government emergency-response chain (Intel, Resource, Policy, Comms, and Orchestrator agents that read real incoming incidents and auto-authorize real government action under real delegated-authority tiers, instantly, with no human in the loop). It worked. But it left exactly the accountability gap above: decisions got made in the name of a real District Magistrate, Police Commissioner, or the DDMA (chaired by the Chief Minister) — and that person had no real way to know, unless they happened to check a screen.

CALL-E was the obvious answer: the one channel that actually reaches someone during a real crisis is a phone ringing, not another unread notification.

What it does

authority-signoff-call is the accountability layer CALL-E adds to GovOS: the moment GovOS auto-authorizes an action under a real authority tier, it places a real CALL-E phone call to that specific accountable official's own pre-registered number. The call explains the decision in plain language and asks for one thing — CONFIRM it as recorded, or OVERRIDE it. The structured result feeds into the exact same function GovOS's own dashboard "Override" button calls — the phone call isn't a separate decision path, it's another way into the one that already existed.

The same pattern generalized to a second real trigger in production: when one government office tags another on a shared incident comment and needs an urgent reply, GovOS places the same kind of call — same safe-by-default gating, same single consented number — telling them they've been tagged and a reply is needed now.

It's safe by default everywhere: with no CALLE_API_KEY, no registered phone number, or the enable flag not explicitly true, it never places a real call — it logs exactly what it would have said and returns unclear. A busy line, no answer, or an API error also resolves as unclear rather than raising, so a flaky phone line can never wedge an incident that already resolved itself autonomously.

How we built it

  • The core call logic lives in signoff_call.py, using the CALL-E Python SDK's CalleClient.calls.create_and_wait() — wrapped in asyncio.to_thread() since it blocks internally via time.sleep() while polling for the call to complete.
  • GovOS's main.py fires the call as a background asyncio task the instant an authority-tiered approval is created (or a tagged comment is posted), so the incident response itself never blocks waiting on a phone call.
  • We packaged the pattern as a standalone, GovOS-independent Agent Skill (SKILL.md, references/, assets/) plus a runnable Python app with a preview/request CLI, and submitted it to CALL-E's community repository — documenting two integration surfaces: MCP (for an interactive coding agent placing the call on someone's behalf) and the direct SDK (for a backend service firing it autonomously, which is what GovOS actually uses).
  • Every example and fixture in the submission — including the dry-run script capture — is generated directly from the real running code, not hand-typed, so the docs can't drift from what the code actually says.

Challenges we ran into

  • CALL-E's own safety classifier rejected our first script outright (HTTP 422): an earlier version described the decision in direct operational language ("Deploy Medical/Ambulance Unit... hospital access blocked... emergency procurement"), and CALL-E correctly flagged it as seeking "an operational decision for an active emergency or disaster response." That was CALL-E working exactly as it should — we rewrote the call script to state plainly, up front, that it's a post-hoc review of an already-recorded log entry, never a live directive, rather than relying on a classifier to infer that from context.
  • calle-ai requires Python 3.11+, but GovOS's existing environment was pinned to 3.10 for the original hackathon submission. Rather than risk that working setup, we stood up a parallel 3.13 virtualenv alongside it.
  • Windows' default console codepage doesn't handle the ₹ symbol our real amount-formatting produces, which crashed a plain CLI preview — fixed properly with stdout.reconfigure(encoding="utf-8") rather than stripping the symbol.
  • Getting the actual CalleClient call signature right without guessing — we read the installed package's source directly (inspect.getsource) rather than assuming parameter names, since a wrong guess here means a real, wasted phone call.

Accomplishments that we're proud of

  • This isn't a mocked demo: we verified it against the live CALL-E API — a real call connected, the recipient's phone rang, they answered and said confirm, and GovOS's own audit trail immediately reflected overridden_by: "Chief Minister, Government of NCT of Delhi (via phone)" on the exact approval record, resolving the incident.
  • The same accountability primitive turned out to generalize past its original use case — the tag-a-comment trigger came for free once the underlying pattern (one real call, one pre-consented number, framed plainly as non-emergency, safe-by-default) existed.

What we learned

  • A platform's safety classifier rejecting your call script isn't a bug to route around — it's a real, working guardrail, and the fix is to make your own intent legible in plain language, not to find a way past it.
  • Designing a call script for a high-stakes, autonomous government-decision context is genuinely different from a casual reminder or scheduling call: every sentence has to survive being read back in a transcript as evidence of what was actually asked and answered.
  • "One real call to one pre-consented number, framed honestly" is a small enough primitive that it generalizes further than we expected — we didn't set out to build a second calling pattern, it just showed up once the first one existed.

What's next

  • Extending the accountable-persona set past the Chief Minister to the District Magistrate and Police Commissioner tiers individually, each with their own registered line.
  • Moving off polling (create_and_wait) to CALL-E's webhook-based result delivery, so GovOS doesn't hold a background task open for the duration of the call.
  • Wiring more of GovOS's existing decision points — not just approvals and tags — through the same accountability-call pattern.

Built With

Share this project:

Updates

Submission history