Inspiration
Volunteer-driven community organizations often lose a surprising amount of human time to small coordination problems. One cancellation can trigger a chain of messages: finding an eligible replacement, checking availability, handling constraints, preventing double-booking, and deciding whether a coordinator actually needs to be interrupted.
Most AI agents focus on doing more. QUORUM started from a different question:
Can an agent solve routine coordination problems while consuming as little human attention as possible?
That became the core idea behind QUORUM — treating human attention as a scarce operational resource.
What it does
QUORUM is an attention-aware autonomous coordination agent for small community organizations.
When a volunteer cancels, QUORUM can:
- detect the staffing gap,
- determine eligible replacements,
- rank candidates using deterministic rules,
- coordinate with volunteers through an AI negotiator,
- understand conditional responses such as "I can do it, but I need a ride",
- resolve ordinary blockers such as transport,
- update the assignment,
- record its decisions,
- and escalate to a human only when genuine judgment is required.
The system uses four policy routes:
GREEN — execute safe and reversible actions automatically.
YELLOW — create a cancellable pending effect before settlement.
RED — stop automation and request human judgment.
SILENT / DEFER — intentionally take no action while recording the decision.
QUORUM also maintains an Attention Budget. Instead of notifying a coordinator about every issue, the system treats interruptions as limited resources that should only be spent when necessary.
Critical safety cases always override the budget.
How we built it
QUORUM is built in Python using the Strands Agents SDK.
The system uses two persistent agent roles:
- a Coordinator Agent for organization-level planning and tool selection,
- and a Negotiator Agent for individual volunteer conversations.
For the working submission, both agents use Google Gemini through Strands' provider abstraction.
The main design principle is:
LLM proposes; deterministic code disposes.
The language model handles language understanding, negotiation, structured interpretation, and tool selection.
Deterministic application code remains authoritative over:
- staffing calculations,
- eligibility,
- candidate ranking,
- contact limits,
- assignment capacity,
- idempotency,
- safety rules,
- escalation thresholds,
- Attention Budget accounting,
- and settlement state transitions.
A BeforeToolCall routing layer evaluates actions before important side effects are executed.
The system also includes durable sessions, persistent human interrupts, cancellable pending effects, assignment concurrency protection, an auditable decision feed, FastAPI endpoints, and Telegram integration.
The demo uses a completely synthetic organization called Riverside Food Bank, with synthetic shifts and volunteers.
What we demonstrated
One tested scenario begins with a volunteer cancellation.
QUORUM detects the gap, deterministically ranks eligible candidates, and begins a negotiation.
When the volunteer responds:
"I can do it, but I need a ride."
the system classifies the response as a conditional acceptance, identifies the condition as transport, finds an available synthetic transport option, confirms the assignment, and resolves the staffing gap without requiring a human interruption.
A second scenario demonstrates the safety boundary.
Messages involving injury or complaints are classified as outside normal autonomous coordination and routed to RED, producing a persistent human interrupt.
Prompt-injection-shaped messages are treated as untrusted input and cannot override application policy or directly modify assignment state.
The current automated test suite passes 28 tests with 0 failures.
Challenges we faced
One major challenge was balancing useful AI autonomy with deterministic control.
We did not want a language model to directly decide who is eligible, modify capacity constraints, spend human attention, or override safety policies. Separating probabilistic reasoning from deterministic authority became one of the most important architectural decisions in the project.
We also implemented durable human-in-the-loop behavior so an interruption can survive a process restart and still resolve a side effect exactly once.
The original plan was to validate the model path using Amazon Bedrock. AWS account activation issues prevented live Bedrock validation within the hackathon window, so we used Strands' provider abstraction with a verified Gemini integration while keeping the rest of the agent architecture unchanged.
What we learned
The most important lesson was that agent quality is not only about how many tasks an AI system can perform.
For real human workflows, knowing when not to interrupt, when not to act, and when to hand control back to a person can be just as important.
We also learned the value of keeping language intelligence separate from operational authority. The model is useful for interpreting messy human language, but deterministic software is still better suited for safety constraints, concurrency, capacity, and policy enforcement.
What's next
Future work includes:
- Amazon Bedrock integration,
- deployment on AWS infrastructure,
- AgentCore integration,
- live DynamoDB persistence,
- EventBridge-based event ingestion,
- additional communication channels,
- richer Attention Budget analytics,
- larger evaluation scenarios,
- and testing with real community organizations.
QUORUM's long-term goal is simple:
Handle the ordinary quietly, and preserve human attention for the decisions that genuinely need it.
Log in or sign up for Devpost to join the conversation.