Skip to main content
Glama

AgentCore

CI TypeScript Node.js License Roadmap Buy Me a Coffee

Self-hosted AI incident triage with checkpointed resume and episodic memory.

When an alert fires, AgentCore runs a 4-step pipeline — recall similar past incidents, plan tool calls with an LLM, query your logs/metrics/runbooks via MCP, synthesize a post-mortem — and posts the result back to Slack in ~30 seconds. Every step is checkpointed to Postgres so a crash mid-investigation resumes from the failed step, not from scratch. Every resolved incident is written into pgvector memory so the second DB deadlock surfaces what fixed the first one.

Apache-2.0 · runs on your infra · works with local models · no incident data ever leaves your network

AgentCore UI demo


Table of Contents


Related MCP server: mcp-incident-responder

Quickstart

Every tool has a deterministic simulation fallback — the full stack runs with zero credentials.

# Pull and run — no build step, no .env required
curl -fsSL https://raw.githubusercontent.com/theprodsde/agentcore/main/docker-compose.demo.yml -o agentcore-demo.yml
docker compose -f agentcore-demo.yml up

Open http://localhost:3000, click Create Task, and describe an incident:

payments-service p99 latency at 4s after deploy

Or trigger via API:

curl -X POST http://localhost:3000/api/tasks \
  -H "Content-Type: application/json" \
  -d '{"goal": "payments-service p99 latency at 4s after deploy"}'

Watch the checkpoint timeline stream live. Grab the post-mortem at /api/tasks/<id>/export.md.

Have an OpenAI key? OPENAI_API_KEY=sk-... docker compose -f agentcore-demo.yml up upgrades planning and synthesis to a real LLM. Prefer building from source? git clone https://github.com/theprodsde/agentcore && cd agentcore && docker compose up --build

Manual

npm install
cp .env.example .env         # fill in DATABASE_URL + OPENAI_API_KEY

# Start Postgres with pgvector
docker run -d -e POSTGRES_USER=agentcore -e POSTGRES_PASSWORD=agentcore \
  -e POSTGRES_DB=agentcore -p 5432:5432 pgvector/pgvector:pg16

npm run db:migrate            # creates the pgvector extension + applies migrations
npm run dev

Prebuilt images on GHCR: docker pull ghcr.io/theprodsde/agentcore:latest Jaeger UI: http://localhost:16686

# Post-Mortem: payments-service p99 latency at 4s after deploy

**Trace ID:** `tr-7q6d5xhl9-8193`  **Duration:** 8.3s  **Retries:** 0

## Summary
The payments-service experienced a latency spike to 4230 ms, well above the 1000 ms SLO.
Deadlock conditions and lock wait timeouts were logged concurrently.

## Probable Cause
Resource contention in the payments-service database layer, specifically transaction locking
caused by insufficient connection pool sizing after the deploy.

## Affected Systems
- `payments-service`
- `postgres-primary`

## Next Actions
1. Scale horizontal replicas of payments-service to reduce per-instance load.
2. Increase Postgres connection pool size and investigate slow-query patterns.
3. Consult the High Latency Runbook for payments-service.

## Checkpoint Timeline
| Step | Name              | Status  | Duration |
|------|-------------------|---------|----------|
| 1    | memory retrieval  | success | 1.3s     |
| 2    | planner           | success | 4.7s     |
| 3    | execution         | success | 7ms      |
| 4    | synthesizer       | success | 2.4s     |

Features

Feature

Detail

Checkpointed orchestration

Every step persists input/output to Postgres; resumes from the last failed step — no re-running successful steps

Episodic memory

Incidents embedded with text-embedding-3-small, retrieved by pgvector cosine similarity with time-decay re-ranking

Dynamic MCP tool selection

LLM planner receives a live tool manifest and outputs per-tool args; 0/1 Knapsack DP prunes to fit a time budget

5 built-in MCP tools

search_logs → Loki · get_metrics → Prometheus · search_runbook → runbook API · create_ticket → Linear · list_services

Incident deduplication

Jaccard + bounded Levenshtein DP + LCS — returns an existing task if a match is found within 10 minutes

OpenTelemetry tracing

Every task is a root span; every step a child span; trace_id/span_id in every Pino log line

JWT auth + multi-tenancy

HS256 tokens, per-team task/memory isolation; auth is a no-op when JWT_SECRET is unset

Webhook ingestion

PagerDuty, OpsGenie, Alertmanager — HMAC-verified payloads create tasks automatically

Slack integration

!incident <description> triggers the full pipeline; result posted back to the thread

Post-mortem export

GET /api/tasks/:id/export.md — downloadable Markdown

Metrics dashboard

30-day summary, step p95, weekly trend at /metrics

CLI

node scripts/run.mjs "<goal>" — run investigations from the terminal with live streaming

MCP server

Expose AgentCore to Claude Code / Claude Desktop / Cursor — investigate, query memory, export post-mortems from any MCP client

Dry-run mode

Full pipeline without writing to memory or creating tickets

Graceful shutdown

SIGTERM → flush OTel spans → drain DB pool → close MCP subprocess


How It Works

%%{init: {'theme': 'base', 'themeVariables': {
  'primaryColor': '#dbeafe',
  'primaryTextColor': '#1e3a5f',
  'primaryBorderColor': '#3b82f6',
  'lineColor': '#64748b',
  'secondaryColor': '#ede9fe',
  'tertiaryColor': '#f0fdf4',
  'clusterBkg': '#f8fafc',
  'clusterBorder': '#cbd5e1',
  'edgeLabelBackground': '#ffffff',
  'fontFamily': 'ui-sans-serif, system-ui, sans-serif'
}}}%%
flowchart LR
    A["🔔 Alert fires
(Slack · PagerDuty · Alertmanager · API)"] --> B[Task Created]
    B --> S1

    subgraph pipeline ["Checkpointed pipeline — each step persists to Postgres"]
        S1["1 · Memory Retrieval
pgvector cosine similarity
against past incidents"]
        S2["2 · LLM Planner
selects tools from live manifest
with per-tool args"]
        S3["3 · MCP Tool Execution
search_logs · get_metrics
search_runbook · create_ticket"]
        S4["4 · Synthesizer
derives report from tool output
writes resolved incident to memory"]
        S1 --> S2 --> S3 --> S4
    end

    S4 --> R["📋 Result
(Slack thread · Dashboard · export.md)"]

    crash(["💥 crash / timeout"]) -. "resume from
failed step only" .-> pipeline

If any step fails the task pauses with the exact error surfaced. Resume replays from the failed step — completed steps are skipped and their outputs reused, so no LLM calls are duplicated.


Screenshots

Dashboard

Task Detail

Dashboard

Task Detail

Create Task

Failed + Resume

Create Task

Failed

Memory Explorer

Scenarios Playground

Memory

Scenarios


Configuration

Variable

Required

Default

Description

DATABASE_URL

Yes

Postgres connection string (must have pgvector)

OPENAI_API_KEY

LLM steps

OpenAI-compatible key

OPENAI_BASE_URL

No

OpenAI

Override for local models, Azure, etc.

LLM_MODEL

No

gpt-4o-mini

Model for planner + synthesizer

EMBEDDING_MODEL

No

text-embedding-3-small

Embedding model (1536 dims)

JWT_SECRET

No

Enables JWT auth; unset = auth disabled

SLACK_BOT_TOKEN

No

Enables real Slack delivery

SLACK_SIGNING_SECRET

No

Verifies Slack event signatures

MCP_SERVER_URL

No

External MCP server (SSE); unset = spawns bundled server

LOKI_URL

No

simulation

Loki backend for search_logs

PROMETHEUS_URL

No

simulation

Prometheus backend for get_metrics

RUNBOOK_URL

No

simulation

Runbook search API

LINEAR_API_KEY

No

simulation

Linear ticket creation

LINEAR_TEAM_ID

No

Linear team ID

PAGERDUTY_WEBHOOK_SECRET

No

HMAC secret for PagerDuty webhooks

OPSGENIE_WEBHOOK_SECRET

No

HMAC secret for OpsGenie webhooks

ALERTMANAGER_SECRET

No

Shared secret for Alertmanager webhooks

TOOL_BUDGET_MS

No

15000

Max total tool execution time per task

TOOL_CALL_TIMEOUT_MS

No

10000

Hard timeout per MCP tool call

LLM_TIMEOUT_MS

No

60000

Timeout per LLM API call

RATE_LIMIT_RPM

No

30

Max task creations per minute (0 disables)

RETENTION_DAYS

No

forever

Purge tasks + checkpoints older than N days

MEMORY_RETENTION_DAYS

No

forever

Purge episodic memories older than N days

DEFAULT_TEAM_ID

No

Team for Slack/webhook tasks (single-tenant)

DISABLE_TEAM_SIGNUP

No

true blocks POST /api/teams after bootstrap

OTEL_EXPORTER_OTLP_ENDPOINT

No

OTLP endpoint for Jaeger / Grafana Tempo

LOG_LEVEL

No

warn

Pino log level


Integrations

MCP — use from Claude / Cursor

AgentCore exposes itself as an MCP server. Add it to Claude Code or Claude Desktop and ask "investigate the latency spike on payments-service" — it runs the full checkpointed pipeline with your team's memory behind it.

# Claude Code
claude mcp add agentcore --env AGENTCORE_URL=http://localhost:3000 \
  -- node /path/to/agentcore/dist/tools/agentcore-mcp.cjs
// Claude Desktop — claude_desktop_config.json
{
  "mcpServers": {
    "agentcore": {
      "command": "node",
      "args": ["/path/to/agentcore/dist/tools/agentcore-mcp.cjs"],
      "env": {
        "AGENTCORE_URL": "http://localhost:3000",
        "AGENTCORE_TOKEN": "eyJ..."
      }
    }
  }
}

Exposed tools: investigate_incident · get_investigation · search_incident_memory · export_postmortem

During development: npm run mcp runs the server from source.

Slack

Set SLACK_BOT_TOKEN and SLACK_SIGNING_SECRET. In any channel the bot is in:

!incident payments-service p99 latency at 4s after deploy

AgentCore runs the full pipeline and replies in the thread with the structured analysis and ticket link.

Webhooks

HMAC-verified ingestion from three providers — no manual task creation required:

Provider

Endpoint

Verification

PagerDuty

POST /api/webhooks/pagerduty

PAGERDUTY_WEBHOOK_SECRET

OpsGenie

POST /api/webhooks/opsgenie

OPSGENIE_WEBHOOK_SECRET

Alertmanager

POST /api/webhooks/alertmanager

ALERTMANAGER_SECRET header

Local models / Ollama

AgentCore speaks the OpenAI API, so any compatible endpoint works:

ollama pull qwen2.5:14b   # any tool-capable instruct model

# .env
OPENAI_BASE_URL=http://localhost:11434/v1
OPENAI_API_KEY=ollama
LLM_MODEL=qwen2.5:14b

Note: The memory store expects 1536-dimension embeddings (text-embedding-3-small). If your local endpoint can't serve them, embedding calls fail gracefully and memory retrieval falls back to recency + keyword ranking. Configurable embedding dimensions are on the roadmap.


Auth & Multi-tenancy

Auth is disabled by default (JWT_SECRET unset) — all requests proceed. To enable:

# 1. Create a team
curl -X POST http://localhost:3000/api/teams \
  -H "Content-Type: application/json" \
  -d '{"name": "Platform Engineering"}'

# 2. Exchange API key for a JWT
curl -X POST http://localhost:3000/api/auth/token \
  -H "Content-Type: application/json" \
  -d '{"api_key": "agentcore_..."}'

# 3. Use the token
curl http://localhost:3000/api/tasks \
  -H "Authorization: Bearer eyJ..."

Tasks and memories are isolated per team — a token from team A cannot read team B's data. The web dashboard shows a login screen automatically when auth is enabled.

Manage API keys via GET/POST/DELETE /api/teams/:id/api-keys. The last key on a team cannot be revoked. Set DISABLE_TEAM_SIGNUP=true after bootstrapping teams in production.

Login screen


Development

Project structure

%%{init: {'theme': 'base', 'themeVariables': {
  'primaryColor': '#dbeafe',
  'primaryTextColor': '#1e3a5f',
  'primaryBorderColor': '#3b82f6',
  'lineColor': '#64748b',
  'clusterBkg': '#f8fafc',
  'clusterBorder': '#cbd5e1'
}}}%%
mindmap
  root((AgentCore))
    Entry
      server.ts
        Express · Slack · graceful shutdown
      scripts/run.mjs
        CLI with live streaming
    src/routes
      tasks.ts
        CRUD · SSE · resume · dedup · export
      auth.ts
        teams · token exchange · API keys
      memory.ts
        pgvector semantic search
      metrics.ts
        30-day summary · step p95
      webhooks.ts
        PagerDuty · OpsGenie · Alertmanager
    src/server
      executor.ts
        orchestrator · Knapsack tool selection
      auth.ts
        JWT · API key hashing
      mcp.ts
        stdio spawn · SSE client
      cache.ts
        LRU TTL · doubly-linked HashMap
      embeddings.ts
        text-embedding-3-small · LRU memo
      db
        Drizzle schema · pgvector · 5 indexes
    src/utils
      algorithms.ts
        Levenshtein · LCS · Knapsack · Jaccard
      synthesis.ts
        pure deriveSynthesisFromOutput
    tools
      server.ts
        MCP tool server · 5 built-in tools
    tests/unit
      algorithms · auth · executor · slack · tools · utils

Commands

npm run dev            # Dev server with HMR
npm run build          # Production build
npm run lint           # TypeScript type check
npm test               # Unit tests (Vitest)
npm run test:watch     # Watch mode
npm run test:coverage  # Coverage report
npm run test:integration  # Checkpoint/resume integration tests (needs TEST_DATABASE_URL)
npm run db:migrate     # Apply versioned migrations
npm run db:push        # Push schema changes (dev)
npm run db:studio      # Open Drizzle Studio
npm run eval           # Golden-incident triage quality eval (needs running server)
npm run mcp            # Run MCP server from source

Triage quality eval

The demo data is an adversarial world model (tools/simulation.ts): each simulated service has a fixed state (healthy or degraded with a specific failure mode), and log/metric output derives from that state — never from the query. Ask about a deadlock on a service that has a latency regression and the report describes the latency regression.

CI runs a golden-incident eval on every push covering true positives, false alarms on healthy services, an unknown-service case, and an anti-circularity case where the alert's claimed symptom is wrong. Scores gate on both identifying the real cause and not fabricating findings the data doesn't support.

Run it locally: npm run eval (needs a running server). Point scenarios at real backends to benchmark LLM or prompt changes.

Adding a new MCP tool

See tools/README.md. Add the tool definition to TOOL_REGISTRY in tools/server.ts — no other files change. The LLM planner picks it up automatically on the next run.

Further reading

Doc

Contents

PRODUCTION.md

Swapping each stub for a real integration

ARCHITECTURE.md

System map, extension points, scaling seams

DEVELOPMENT.md

Phase roadmap and design decisions

SECURITY.md

Threat model, prompt-injection bounds, responsible disclosure


Contributing

Pull requests are welcome. See CONTRIBUTING.md for setup and conventions.

The easiest first contribution is a new tool backend — Elasticsearch, Grafana, Jira, Datadog. The whole pattern lives in one file and issues labeled good first issue + tool-integration have step-by-step specs.

Please read the PR template before opening a PR.


Roadmap

Tracked on GitHub Projects.

Release

Highlights

v0.2 — Scale

Redis/BullMQ task queue · configurable embedding dims · pgvector-based dedup · ESLint in CI

v0.3 — Intelligence

Runbook auto-import · Slack app-home tab · LLM-graded memory scoring

Community

Elasticsearch · GitHub Issues · Grafana annotations · Datadog · Jira backends


Support

AgentCore is free and open-source under Apache 2.0. If it's saving your team time on incidents:

Buy Me a Coffee PayPal

You can also click Sponsor at the top of the repo on GitHub.


License

Apache 2.0 — see LICENSE.

Available Tools

4 tools
export_postmortemA

Export a completed investigation as a Markdown post-mortem (summary, probable cause, affected systems, next actions, checkpoint timeline).

ParametersJSON Schema
NameRequiredDescriptionDefault
task_idYesTask ID of a completed investigation

TDQS

A3.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It describes the output content but does not explicitly state whether the operation has side effects, requires special permissions, or what happens if the investigation is not completed. 'Export' suggests a read operation but is not explicit, and error conditions are absent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that front-loads the verb and resource, enumerates the output sections, and contains no filler or redundant information. Every element contributes to understanding what the tool does.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With one parameter and no output schema, the description covers the tool's purpose and the content of the output, but it leaves ambiguous how the Markdown is returned (e.g., string, file path) and does not address error cases for non-completed investigations. These are material gaps given the absence of annotations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema provides 100% coverage for the single parameter task_id, describing it as 'Task ID of a completed investigation'. The description adds no additional semantic detail about task_id, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the specific verb 'Export', the resource 'completed investigation', and the output format 'Markdown post-mortem', and lists the exact sections (summary, probable cause, affected systems, next actions, checkpoint timeline). This clearly distinguishes it from siblings like investigate_incident, get_investigation, and search_incident_memory, which serve different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when an investigation is completed and a post-mortem export is needed, but it does not explicitly reference alternatives or state when not to use this tool. The distinction from get_investigation or investigate_incident is left to the agent's inference, so guidance is implied rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_investigationA

Fetch an investigation's status, checkpoint timeline (per-step status and durations), and final report if completed.

ParametersJSON Schema
NameRequiredDescriptionDefault
task_idYesTask ID returned by investigate_incident

TDQS

A3.8/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral disclosure burden. It clearly indicates a read-only operation ('Fetch') and transparently handles the not-completed case ('final report if completed'). It also specifies the response includes status and checkpoint timeline, leaving little ambiguity about what the agent will get.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, well-structured sentence that front-loads the action and enumerates the return contents. No filler, no redundancy. Every part earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (one parameter, no output schema, no annotations) and the schema's full parameter coverage, the description covers the return payload sufficiently. The only gap is the lack of explicit 'use after investigate_incident' guidance in the description, but the schema hints at this, so the tool definition as a whole is nearly complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema covers 100% of the single parameter with a clear description ('Task ID returned by investigate_incident'), so the schema does the heavy lifting. The tool description adds no additional parameter meaning beyond what the schema already provides, fitting the baseline of 3 for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb (Fetch) and resource (investigation) and enumerates exactly what is returned: status, checkpoint timeline with per-step status/durations, and final report if completed. This clearly distinguishes it from siblings like investigate_incident (which starts investigations) and export_postmortem (which exports postmortems).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not state when to use this tool versus alternatives, nor does it mention prerequisites or ordering. The only hint is in the schema parameter description ('Task ID returned by investigate_incident'), but this is not part of the tool description itself, so the agent receives no explicit usage guidance from the description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

investigate_incidentA

Run an AgentCore incident investigation: retrieves similar past incidents from episodic memory, plans tool calls with an LLM, queries logs/metrics/runbooks, and synthesizes a report. Waits for completion by default and returns the synthesized incident report.

ParametersJSON Schema
NameRequiredDescriptionDefault
goalYesIncident description, e.g. 'payments-service p99 latency at 4s after deploy v2.3'
contextNoOptional extra context: alert payload, log snippets, recent changes
dry_runNoSkip side effects (no ticket creation, no memory write). Default false
wait_secondsNoMax seconds to wait for completion (0 = return task_id immediately). Default 120

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without any annotations, the description carries the full burden of behavioral disclosure, and it does well: it reveals that the tool consults episodic memory, invokes an LLM to plan tool calls, queries logs/metrics/runbooks, waits by default, and returns a report. It does not in the description disclose the ticket-creation/memory-write side effects implied by dry_run, but the schema covers that and there is no contradiction.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with no wasted words: the first states the primary action and pipeline, the second states default wait behavior and return value. It is front-loaded and every clause earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a complex orchestrator with no output schema, the description covers the main workflow, default waiting, and the return value, which is enough to call the tool correctly. A minor gap is the lack of explicit mention of the task_id path when wait_seconds=0 and the ability to poll via get_investigation, though the schema does document the immediate-return behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the schema itself provides strong descriptions for goal, context, dry_run, and wait_seconds, including an example and side-effect clarifications. The description adds no per-parameter detail beyond the schema, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with 'Run an AgentCore incident investigation' and then breaks down exactly what that entails: retrieving similar past incidents, planning tool calls with an LLM, querying logs/metrics/runbooks, and synthesizing a report. This clearly differentiates it from sibling tools like get_investigation, search_incident_memory, and export_postmortem, which focus on retrieval/export rather than running a full investigation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description makes it clear this tool is for starting a new investigation and returning a synthesized report, including the default blocking behavior. It does not explicitly name alternatives or say 'use get_investigation if you already have a task_id', but the purpose is clear enough for an agent to select it appropriately.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_incident_memoryA

Semantic search over AgentCore's episodic memory of past incidents and their outcomes. Use to find how similar incidents were resolved before.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoMax results (default 5)
queryYesIncident description or error pattern to search for

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. 'Semantic search' implies a non-destructive read operation, which is a useful behavioral clue. However, it does not explicitly state that it is read-only, mention any permissions, or describe limitations (e.g., result sorting, availability of historical data). For a search tool, the implicit non-destructive nature is adequate but not fully explicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences with no redundancy. The tool's core function is front-loaded and the usage hint follows directly. Every word contributes to understanding what the tool does and when to use it.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no output schema, the description adequately explains what is searched (past incidents and outcomes) and gives a practical use case. It does not detail the result shape or pagination behavior, but the `limit` parameter and the nature of semantic search make it sufficient for an agent to call it correctly. It could be more complete by mentioning what fields results contain, but it is not a major gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already provides descriptions for both parameters (query and limit) at 100% coverage, so the description adds no additional parameter-level meaning. It simply restates the search intent. Per guidelines, high schema coverage sets the baseline at 3, and the description does not elevate beyond that.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: 'Semantic search over AgentCore's episodic memory of past incidents and their outcomes.' This clearly distinguishes from siblings like investigate_incident or export_postmortem by focusing on historical resolution lookup. The purpose is unambiguous and immediately actionable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides a clear usage context: 'Use to find how similar incidents were resolved before.' This tells an agent when to invoke it. It does not explicitly mention alternatives or when not to use it, but the context is strong enough that no further guidance is needed for a simple search tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 4 tool updatesv0.1.0
    • First observedexport_postmortem
    • First observedget_investigation
    • First observedinvestigate_incident
    • First observedsearch_incident_memory

TDQS

A4/5.0

Scored across 4 tools

Disambiguation5/5

Each tool has a clearly distinct purpose: investigating, fetching investigation status/reports, exporting post-mortems, and searching past incident memory. There is no meaningful overlap or ambiguity between them.

Naming Consistency5/5

All tool names follow the same verb_noun snake_case pattern: investigate_incident, get_investigation, export_postmortem, search_incident_memory. The naming is predictable and consistent.

Tool Count5/5

Four tools is well-scoped for an incident investigation server. Each tool covers a distinct step in the workflow without bloat or redundancy.

Completeness4/5

The core investigation lifecycle is covered: run, retrieve, search memory, and export post-mortem. A listing or cancellation capability for investigations would improve completeness, but agents can still accomplish the primary workflow without dead ends.

Maintenance

ActivityMaintained
ResponsivenessResponsive

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables autonomous SRE incident investigation by allowing users to describe incidents in natural language. The agent follows a governed state machine to gather read-only evidence and produce grounded conclusions.
    MIT
  • F
    license
    Not graded
    quality
    B
    maintenance
    An MCP-native AI incident response system that empowers agents to investigate production incidents, collect evidence, hypothesize root causes, and drive controlled remediation and recovery verification.
    1
    -