Last updated · Santosh Kumar Radha

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

PieceWhat it doesIn AgentField
TriggersStart work from GitHub, Stripe, Slack, PagerDuty and other webhooks, or a schedule@on_event(...), @on_schedule("*/15 * * * *")
Durable executionQueue work, survive restarts, report statusPOST /api/v1/execute/async/<target>, PostgreSQL-backed queue
DecisionsTyped model output you can branch onapp.ai(..., schema=Decision)
EscalationWait for a person, for hours or daysapp.pause(...), default expiry 72 hours
AuditWhat ran, why, and who approvedNotes, workflow DAG, signed credentials
ModelsAny provider, or local100+ models via LiteLLM in Python, including Ollama
HostingWhere it runsSelf-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.

python
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:

python
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

Checked 2026-11-21 against the AgentField docs and each tool's own documentation on that date.