mcp-AgentCore
Creates Linear tickets via the built-in create_ticket MCP tool during incident triage.
Accepts OpsGenie webhooks with HMAC verification to automatically create incident tasks.
Accepts PagerDuty webhooks with HMAC verification to automatically create incident tasks.
Queries Prometheus metrics through the built-in get_metrics MCP tool to support incident investigations.
Allows triggering incident investigations from Slack with !incident <description> and posts the resulting post-mortem back to the thread.
AgentCore
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

Table of Contents
Related MCP server: mcp-incident-responder
Quickstart
Every tool has a deterministic simulation fallback — the full stack runs with zero credentials.
Docker (recommended)
# 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 upOpen http://localhost:3000, click Create Task, and describe an incident:
payments-service p99 latency at 4s after deployOr 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 upupgrades 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 devPrebuilt images on GHCR:
docker pull ghcr.io/theprodsde/agentcore:latestJaeger 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 |
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 |
|
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; |
JWT auth + multi-tenancy | HS256 tokens, per-team task/memory isolation; auth is a no-op when |
Webhook ingestion | PagerDuty, OpsGenie, Alertmanager — HMAC-verified payloads create tasks automatically |
Slack integration |
|
Post-mortem export |
|
Metrics dashboard | 30-day summary, step p95, weekly trend at |
CLI |
|
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" .-> pipelineIf 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 |
|
|
Create Task | Failed + Resume |
|
|
Memory Explorer | Scenarios Playground |
|
|
Configuration
Variable | Required | Default | Description |
| Yes | — | Postgres connection string (must have pgvector) |
| LLM steps | — | OpenAI-compatible key |
| No | OpenAI | Override for local models, Azure, etc. |
| No |
| Model for planner + synthesizer |
| No |
| Embedding model (1536 dims) |
| No | — | Enables JWT auth; unset = auth disabled |
| No | — | Enables real Slack delivery |
| No | — | Verifies Slack event signatures |
| No | — | External MCP server (SSE); unset = spawns bundled server |
| No | simulation | Loki backend for |
| No | simulation | Prometheus backend for |
| No | simulation | Runbook search API |
| No | simulation | Linear ticket creation |
| No | — | Linear team ID |
| No | — | HMAC secret for PagerDuty webhooks |
| No | — | HMAC secret for OpsGenie webhooks |
| No | — | Shared secret for Alertmanager webhooks |
| No |
| Max total tool execution time per task |
| No |
| Hard timeout per MCP tool call |
| No |
| Timeout per LLM API call |
| No |
| Max task creations per minute ( |
| No | forever | Purge tasks + checkpoints older than N days |
| No | forever | Purge episodic memories older than N days |
| No | — | Team for Slack/webhook tasks (single-tenant) |
| No | — |
|
| No | — | OTLP endpoint for Jaeger / Grafana Tempo |
| No |
| 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 deployAgentCore 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 |
|
|
OpsGenie |
|
|
Alertmanager |
|
|
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:14bNote: 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.

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 · utilsCommands
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 sourceTriage 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 |
Swapping each stub for a real integration | |
System map, extension points, scaling seams | |
Phase roadmap and design decisions | |
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.
Bugs → bug report template
New tools / features → feature request template
Questions / deployment stories → Discussions
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:
You can also click Sponsor at the top of the repo on GitHub.
License
Apache 2.0 — see LICENSE.
Available Tools
4 toolsexport_postmortemA
Export a completed investigation as a Markdown post-mortem (summary, probable cause, affected systems, next actions, checkpoint timeline).
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes | Task ID of a completed investigation |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes | Task ID returned by investigate_incident |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| goal | Yes | Incident description, e.g. 'payments-service p99 latency at 4s after deploy v2.3' | |
| context | No | Optional extra context: alert payload, log snippets, recent changes | |
| dry_run | No | Skip side effects (no ticket creation, no memory write). Default false | |
| wait_seconds | No | Max seconds to wait for completion (0 = return task_id immediately). Default 120 |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 5) | |
| query | Yes | Incident description or error pattern to search for |
TDQS
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.
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.
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.
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.
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.
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.
4 tool updates
v0.1.0- First observed
export_postmortem - First observed
get_investigation - First observed
investigate_incident - First observed
search_incident_memory
TDQS
Scored across 4 tools
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.
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.
Four tools is well-scoped for an incident investigation server. Each tool covers a distinct step in the workflow without bloat or redundancy.
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
Related MCP Connectors
Cross-tool persistent memory and context for AI assistants over MCP.
- memnodeOAuthdev.memnode
Persistent, inspectable memory for AI agents with lineage, correction, and a hosted MCP endpoint.
Private-by-default, local-first memory/context/task orchestrator for MCP apps and agents.
AI Reasoning Cache & Consensus Layer with 11 MCP tools via Streamable HTTP.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceA multi-agent MCP server that turns LLMs into an autonomous incident-response copilot, enabling rapid investigation, correlation, and remediation of production incidents.MIT
- FlicenseNot gradedqualityCmaintenanceAn AI-native incident response server that exposes diagnostic tools (system status, error logs, ticket creation) via MCP, enabling LLM agents to autonomously assess and respond to incidents.-
- AlicenseNot gradedqualityBmaintenanceEnables 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
- FlicenseNot gradedqualityBmaintenanceAn 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-





