How to Monitor Agno with Vigilmon

Agno (formerly Phidata) is an open-source framework for building multi-modal AI agents with memory, knowledge bases, and tool integrations across 20+ LLM providers. You can spin up an agent with a web-based playground UI, coordinate multi-agent teams, and run long-lived sessions — but all of that infrastructure needs uptime monitoring. Vigilmon gives you HTTP health checks, agent playground availability monitoring, heartbeat checks for background agent workers, and instant alerts when any part of your Agno deployment goes dark.

What You'll Set Up

HTTP uptime monitor for the Agno playground UI and agent API
Cron heartbeat for long-running agent session workers
SSL certificate expiry alerts for your agent endpoints
Alert channels for immediate notification on agent failures

Prerequisites

Agno installed (pip install agno) with at least one agent service running
An HTTP or API endpoint exposed for your agent (playground UI or custom FastAPI wrapper)
A free Vigilmon account

Step 1: Add a Health Endpoint to Your Agno Service

Agno agents are typically served behind a FastAPI or similar HTTP layer. Before setting up monitoring, expose a /health route that Vigilmon can probe:

from fastapi import FastAPI
from agno.agent import Agent
from agno.models.openai import OpenAIChat

app = FastAPI()

agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    description="A helpful assistant",
)

@app.get("/health")
async def health():
    return {"status": "ok", "agent": "ready"}

@app.post("/run")
async def run_agent(message: str):
    response = agent.run(message)
    return {"response": response.content}

If you're using the Agno playground (phi ws up), the playground itself exposes a web UI — monitor its root URL directly. For custom deployments, adding /health gives you a richer probe that confirms the agent is initialized and not just the HTTP server.

Step 2: Monitor Your Agno Agent Endpoint

With your health endpoint live, add a Vigilmon monitor:

Log in to vigilmon.online and click Add Monitor.
Set Type to HTTP / HTTPS.
Enter your agent's health URL: https://agents.yourdomain.com/health
Set Check interval to 1 minute.
Set Expected HTTP status to 200.
Click Save.

For the Agno playground UI, monitor its root path:

https://playground.yourdomain.com/

A 200 response confirms the playground is reachable and the Agno stack is running.

Step 3: Heartbeat Monitoring for Agent Session Workers

Long-running Agno agents — those handling scheduled knowledge updates, background tool calls, or periodic memory consolidation — don't serve HTTP traffic. Use a Vigilmon cron heartbeat to confirm they complete on schedule:

In Vigilmon, click Add Monitor → Cron Heartbeat.
Set the expected ping interval to match your job frequency (e.g. 30 minutes).
Copy the heartbeat URL (e.g. https://vigilmon.online/heartbeat/abc123).

Add the ping to your agent worker after a successful run:

import httpx
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    description="Scheduled knowledge updater",
)

def run_knowledge_update():
    agent.run("Summarize and store the latest news")

    # Signal success to Vigilmon
    httpx.get("https://vigilmon.online/heartbeat/abc123", timeout=5)

if __name__ == "__main__":
    run_knowledge_update()

If the agent crashes or hangs before reaching the ping, Vigilmon alerts after the expected interval passes — catching silent failures that logs might miss.

Step 4: Monitor Multi-Agent Team Orchestration

Agno supports multi-agent teams where a coordinator delegates tasks to specialized sub-agents. Each agent in the team may have its own service endpoint. Add a monitor for each critical agent:

https://agents.yourdomain.com/health/researcher
https://agents.yourdomain.com/health/writer
https://agents.yourdomain.com/health/coordinator

You can expose per-agent health checks by registering routes per agent instance:

@app.get("/health/{agent_name}")
async def agent_health(agent_name: str):
    if agent_name in agent_registry and agent_registry[agent_name].is_ready():
        return {"status": "ok", "agent": agent_name}
    return JSONResponse(status_code=503, content={"status": "unavailable"})

Set Vigilmon's Expected HTTP status to 200 and configure separate alerts per agent so you know which team member failed.

Step 5: SSL Certificate Alerts

If your Agno playground or agent API is served over HTTPS, add SSL monitoring to catch certificate expiry before it breaks client connections:

Open the HTTP monitor for your agent endpoint (created in Step 2).
Enable Monitor SSL certificate under the SSL section.
Set Alert when certificate expires in less than 21 days.
Click Save.

A 21-day window gives you enough runway to renew before agents start throwing TLS errors.

Step 6: Configure Alert Channels

Go to Alert Channels in Vigilmon and add Slack, email, or a webhook endpoint.
Set Consecutive failures before alert to 2 on each monitor — LLM API cold starts can cause single-probe timeouts that don't indicate a real outage.
Use Maintenance windows when deploying new agent versions:

# Before deploying a new agent version
curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"monitor_id": "abc123", "duration_minutes": 5}'

# Deploy your updated Agno agent
docker compose up -d --build

# Maintenance window expires automatically

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP endpoint | /health on agent service | Agent crash, LLM init failure | | Playground UI | Root URL | Playground down, networking issue | | Cron heartbeat | Heartbeat URL | Worker crash, missed schedule | | SSL certificate | Agent domain | Certificate expiry |

Agno gives you a powerful framework for running production AI agents — but agent infrastructure is only as reliable as your monitoring. With Vigilmon watching your agent endpoints, heartbeats, and SSL certificates, you catch failures before your users do and keep your multi-modal agent teams running around the clock.