Agents that run 24/7 for claims, IT ops and support tickets
The stack for AI agents that work around the clock on claims, IT operations or support tickets and escalate to a person when they should.
An agent that processes insurance claims, IT incidents or support tickets around the clock needs five pieces: triggers that start it from events and schedules, a durable queue so work survives restarts, structured model decisions, an escalation step that waits for a person, and an audit trail of every decision; AgentField, an open-source (Apache 2.0) control plane, provides all five in one runtime, with your models and your infrastructure. The alternative is assembling them yourself from a workflow engine, a queue, cron, an approval service and a log store.
At a glance: the stack
| Piece | What it does | In AgentField |
|---|---|---|
| Triggers | Start work from GitHub, Stripe, Slack, PagerDuty and other webhooks, or a schedule | @on_event(...), @on_schedule("*/15 * * * *") |
| Durable execution | Queue work, survive restarts, report status | POST /api/v1/execute/async/<target>, PostgreSQL-backed queue |
| Decisions | Typed model output you can branch on | app.ai(..., schema=Decision) |
| Escalation | Wait for a person, for hours or days | app.pause(...), default expiry 72 hours |
| Audit | What ran, why, and who approved | Notes, workflow DAG, signed credentials |
| Models | Any provider, or local | 100+ models via LiteLLM in Python, including Ollama |
| Hosting | Where it runs | Self-hosted only: Docker, Kubernetes, cloud VMs or containers |
A claims agent that escalates
This is the enterprise sample from the AgentField README: low-confidence decisions pause for a person, then the result goes to the next agent.
from agentfield import Agent, AIConfig
from pydantic import BaseModel
app = Agent(
node_id="claims-processor",
version="2.1.0",
ai_config=AIConfig(model="anthropic/claude-sonnet-4-20250514"),
)
class Decision(BaseModel):
action: str # "approve", "deny", "escalate"
confidence: float
reasoning: str
@app.reasoner(tags=["insurance", "critical"])
async def evaluate_claim(claim: dict) -> dict:
decision = await app.ai(
system="Insurance claims adjuster. Evaluate and decide.",
user=f"Claim #{claim['id']}: {claim['description']}",
schema=Decision,
)
if decision.confidence < 0.85:
await app.pause(
approval_request_id=f"claim-{claim['id']}",
approval_request_url=f"https://internal.acme.com/approvals/claim-{claim['id']}",
expires_in_hours=48,
)
await app.call("notifier.send_decision", input={
"claim_id": claim["id"],
"decision": decision.model_dump(),
})
return decision.model_dump()
app.run()The threshold, the 48-hour window and the downstream agent are business choices; the mechanism is the same for a refund, a firewall change or a ticket reply.
Starting work without a person
Webhook triggers bind a reasoner to an event source. The control plane provisions the URL, verifies the signature, drops replays and dispatches the event:
from agentfield import Agent, TriggerContext, on_event, on_schedule
app = Agent(node_id="ops-agent")
@app.reasoner()
@on_event(
source="github",
types=["pull_request"],
secret_env="GITHUB_WEBHOOK_SECRET",
)
async def on_pr(event: dict, trigger: TriggerContext | None = None):
pr = event["pull_request"]
return {"action": event["action"], "title": pr["title"]}
@app.reasoner()
@on_schedule("*/5 * * * *")
async def heartbeat(_input, trigger: TriggerContext | None = None):
return {"fired_at": trigger.received_at.isoformat()}
app.run()Built-in sources include stripe, github, slack, linear, sentry, hubspot, calendly, pagerduty, plus generic_hmac and generic_bearer for your own systems. The cron source supports the common five-field syntax and defaults to UTC; it does not support seconds, named months or @hourly.
Surviving the night
Deferred execution persists every job to PostgreSQL before a worker picks it up, so a control plane restart does not lose it, and a worker pool keeps one busy agent from starving the rest. Completion webhooks are HMAC-signed and retried (3 attempts by default, then a dead letter queue). Prometheus metrics such as agentfield_gateway_queue_depth and agentfield_step_retries_total tell on-call staff when the queue is backing up. A blog walkthrough, agents that run for three days, shows a long job end to end.
When something else fits better
- You already run Temporal for business processes. Its durable execution and Signals-based human approval, which can wait "hours, days or indefinitely" per its own recipe, are proven. Compare in detail at AgentField vs Temporal.
- Operations staff build the automations, not developers. n8n has an AI Agent node and lets a person approve a tool call through Slack, Teams, email and more. It is fair-code under the Sustainable Use License and self-hostable.
- Your tickets and incidents already live in ServiceNow. Its AI Agent Orchestrator coordinates agents on the same platform as the records, which avoids integration work.
- One agent graph with interrupts. LangGraph's
interrupt()with a durable checkpointer handles escalation inside a single graph.
Honest limits: there is no hosted AgentField, so someone on your team operates the control plane and PostgreSQL. The customer support example in the docs is still a placeholder; the building blocks above are documented, the packaged example is not yet.
Questions people ask
What stack do I need for an agent that processes insurance claims 24/7 and escalates to a human?
Event triggers, a durable job queue, structured model output, a human approval step that can wait days, and an audit trail. AgentField bundles these: @on_event and @on_schedule triggers, a PostgreSQL-backed async queue, app.ai(schema=...), app.pause() for escalation and signed execution records.
Can AI agents handle IT ops and support tickets autonomously?
They can handle the routine share and hand the rest to people. Design it so the agent acts alone only above a confidence threshold or within a policy limit, and pauses for a person otherwise; in AgentField that is a branch around app.pause() and a tag policy on what the agent may call.
What happens if the server restarts in the middle of a job?
In AgentField, async executions are persisted to PostgreSQL before a worker runs them, and approval waits are stored by the control plane rather than in agent memory. After a restart, queued work continues and a waiting agent can reconnect with app.wait_for_resume().
Can I trigger agents from PagerDuty or Sentry alerts?
Yes. pagerduty and sentry are built-in webhook trigger sources in AgentField, alongside GitHub, Stripe, Slack, Linear and HubSpot. Signatures and replays are checked by the control plane before your reasoner runs.
Is there a managed service so we do not have to run it?
No. AgentField is open source and self-hosted only. If nobody on the team can operate a service and a database, a hosted automation product is the better fit.
Sources
- AgentField docs, checked 2026-11-21: webhook triggers, cron, deferred execution, webhooks, human-in-the-loop, audit, customer support example
- Agent-Field/agentfield README, checked 2026-11-21 (claims sample)
- Temporal human-in-the-loop recipe, n8n human-in-the-loop for tools, n8n repo and licence, ServiceNow press release, March 2025, LangGraph interrupts, checked 2026-11-21
Checked 2026-11-21 against the AgentField docs and each tool's own documentation on that date.