Changelog

With every release, we’re closing the gap between what an SRE wants an AI agent to do and what the agent actually can do.

• More plugins = fewer blind spots in your environment.

• A better Quickstart = less friction to get something useful running.

• Claude Desktop support = faster iteration for builders.

• And now, community contributions = a growing ecosystem.

The result: agents that are more capable, more contextual, and closer to production-ready automation.

Here’s what’s new 👇

New plugins, more power for your agents

The biggest blocker we hear from teams building AI agents for incident response is access. Your agents can’t take meaningful action without the right data and tools. This release removes even more of those barriers:

• Third-party MCP servers: Connect Unpage to any MCP server—whether it’s for your cloud provider, observability stack, or source code system. Each server gets its own prefix so you can route agent requests cleanly. Docs →

• Custom alerts: Send any alert to your Unpage agent with a webhook. If it can send a webhook, Unpage can respond. Docs →

• Graph plugin: Query your infrastructure knowledge graph directly, letting agents answer topology and dependency questions on the fly. Docs →

• SolarWinds log search: Extend log visibility into SolarWinds environments, enabling faster investigations where it’s already in use. Docs →

• COMING SOON: Rootly plugin (community contribution 🎉): Our first plugin from the community integrates with Rootly’s incident management API, letting agents pull incident details, post updates, and take actions like acknowledge, mitigate, or resolve. A great proof point of how Unpage can be extended by anyone.

Together, these plugins help you shrink the gap between alert noise and actionable context.

Other improvements

• Improved Quickstart: New users now get a guided flow that introduces Unpage, walks through creating and configuring an agent, runs a first test payload, and surfaces the next steps.

• New MCP example agent: A ready-to-use template for code review and repository operations. It shows how to combine GitHub, Git, and filesystem MCP servers so agents can analyze pull requests or changesets out of the box. View template →

description: "Agent for code review and repository operations"
prompt: "You are a code review expert. Use git and filesystem tools to analyze code changes."

tools:
  - "mcp_git_*"                # All tools from git server
  - "mcp_filesystem_*"         # All tools from filesystem server
  - "mcp_github_create_issue"  # Specific tool from github server

• Claude Desktop support: Use Unpage MCP inside Claude Desktop to make local experimentation and development even easier. Docs →

___

Thanks again to everyone building and experimenting with Unpage. This release is all about making agents more capable out of the box, from broader plugin coverage to a smoother Quickstart. We’re excited to see how you put these to work in your own environments.

And if you haven’t tried Unpage yet… just run this 👇

curl -fsSL https://install.unpage.ai | bash

Other helpful resources:

👉 GitHub repo

👉 Getting started docs

💬 Join our Slack community to share feedback, swap ideas, and connect with the team.

Every second an alert sits unresolved is time your customers feel the impact. But “resolving” is more than just finding the cause. It’s configuring the tools, digging through logs, and deciding whether action is even required. If that process is clunky, your agents (and, by extension, your engineers) lose valuable time.

Today’s update makes Unpage agents:

• Simpler to configure: picking an LLM is now guided, with sensible defaults and recommendations

• More decisive: your default agent can now (optionally) auto-resolve PagerDuty incidents that don’t require human intervention

• Easier to control: intuitive subcommands mean less CLI guesswork and clutter

• Better at investigation: new log search tools for Datadog and Papertrail let agents go straight to the source

Here’s what’s new 👇

Simplified LLM configuration

Configuring an LLM for your agents used to mean digging into YAML and hunting for the right provider/model syntax. Now, unpage configure walks you through provider and model selection with built-in recommendations and descriptions. Here’s how it works:

LLM configuration docs →

New tool: Auto-resolve PagerDuty incidents

We’ve added a new pagerduty_resolve_incident tool 😎

With it, your default agent can (if you choose) automatically resolve PagerDuty incidents that it determines don’t require further investigation (and even leave a resolution message).

This helps close the loop on false alarms and keeps on-call rotations focused on what actually matters.

PagerDuty plugin docs →

More intuitive subcommands

MCP-related commands (server, tools, and client) are now grouped under a top-level mcp namespace.

Before

# Start the MCP server 
uv run unpage start

After

# Start the MCP server
uv run unpage mcp start

This makes it easier to discover and run all MCP-related commands in one place. Additionally, the visualize command has been removed for now to cut down on noisy output, and the PagerDuty plugin configuration docs have been updated for clarity.

Updated MCP command reference docs →

Updated Agent command reference docs →

Log search for Datadog and Papertrail

Your agents can now query logs directly via the new log_search tools in the Datadog and Papertrail plugins, which means no more switching contexts to find relevant traces or historical events. Just ask your agent to look it up 😄

Datadog log search docs →

Papertrail log search docs →

___

Thanks again to our early alpha users for kicking the proverbial Unpage tires. These updates are aimed squarely at speeding up your investigation-to-resolution loop. We can’t wait to hear what you think.

And for anyone who’s not gotten started yet…

👉 GitHub repo

💬 Join our Slack community to connect with other users and chat directly with the Unpage team

Note: this open source project (formerly referred to as Aptible AI) is now called Unpage 🙂

Every incident starts the same: a lone alert fires, the responder scrambles to piece together what changed, who owns it, and how everything connects. Dashboards, runbooks, disparate Slack threads, and cloud consoles all hold fragments of the answer. Ultimately, this burns precious minutes while customers are already feeling the pain.

Unpage is tackling that problem in a new way — not by giving you an out-of-the-box solution, but by giving you a foundation upon which to build your own.

It first builds a live knowledge graph of your infrastructure, then it gives you an interface by which you can build and deploy your own production-ready AI agents that can read your infra graph, query real tools, and deliver an immediate, well‑informed response (often before your on-call engineers have even opened their laptops). It’s like giving every on‑call engineer an always‑up‑to‑date mental model of prod, plus a custom-built sidekick that can act on it when needed.

Today we’re shipping the first alpha release to a small group of design partners. What follows is a tour of everything you can try right now and how to get started 👇

Agent builder

Most alert responders waste minutes hunting for the right runbook; with router‑selected agents you get immediate, contextual actions instead.

• Declarative YAML agents: Define triggers, prompts, and tool ACLs in one file; no Python inheritance required.

• LLM‑powered router: Feed alerts, web‑hooks, or CLI payloads to the router and it chooses the right agent automatically.

• Starter templates: unpage agent create now scaffolds a fully‑working PagerDuty enrichment agent so you can iterate fast.
  
  

  

  
  

• Easy agent creation: Tweak your prompt template, test the agent to see results immediately, and continue refining until you’re happy with the results your agent is consistently returning

See docs for more info.

Knowledge graph builder

Agents can navigate this graph to understand “what talks to what,” pull metrics for upstream services, and trace blast‑radius automatically. This allows them to really understand your systems and gives you the ability to build agents that are actually useful to you and your specific context.

• Async graph build: Generates a directed graph of every resource, dependency, and owner without blocking your terminal.
  
  

  

  
  

• Profiles: Keep staging, prod, and personal sandboxes in separate graphs while sharing the same plugin configuration.

• Edge‑inference boost: Refactor drops relationship‑resolution time by ~95 %, so graphs with tens of thousands of nodes still feel snappy.

See docs for more info.

Plugins and tools

Plugins are the foundation of Unpage’s extensible architecture, allowing you to build the knowledge graph and provide the LLM with tools (more on that in a second). Each plugin is designed to bridge the gap between your infra and your LLM-powered agents.

Tools are the capabilities that allow Unpage agents to interact with your infrastructure and perform useful operations. They form the bridge between LLMs and real-world systems, enabling AI to take meaningful actions based on its analysis. This is what makes the agents truly useful by enabling them to actually interact with your infrastructure.

See docs for more info on plugins and tools.

To all our early alpha users: Thank you for testing Unpage at its shakiest; we can’t wait to hear what you build and where we can make it better.

👉 Github repo 👈