> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cortex.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Put your Cortex data to work in your agents

> Agent ideas and starter prompts for giving your own agents and automations the org context in Cortex

Use the [Cortex MCP](https://docs.cortex.io/get-started/cortex-ai-assistant/mcp) to give your own agents and automations the same org context your engineers rely on. With it, they can look up who owns a service, what depends on it, how it scores, and what’s been deployed, then act on that context in the tools your teams already use.

These ideas show how to route alerts to the right owner, keep ownership current, chase Scorecard failures, and track migrations. Each one includes a prompt you can give to your coding agent to start building. Replace the values in brackets, like `[Slack channel]`, with your own.

> [!NOTE]
>
> Before you start, [configure the Cortex MCP](https://docs.cortex.io/get-started/cortex-ai-assistant/mcp/configuring-cortex-mcp.md) in the tool you'll build with.

## When something breaks

Every minute a responder spends looking up the owner and the last deploy adds to MTTR. Teams downstream of a breaking change usually find out when their own service fails.

### Triage agent

Runs on every alert or ticket. Finds the owning team, repo, and recent deploys before anyone is paged, and posts them where responders will see them.

```text Prompt theme={null}
Build an agent that runs when [alerting tool] fires. Use the Cortex MCP to find the service the alert names, its owning team, repo and deploys from the last 24 hours, then post a summary to [Slack channel].
```

### Blast-radius checker

Runs on every pull request (PR). Lists the services that depend on the one being changed, and who owns them, right on the PR.

```text Prompt theme={null}
Build a GitHub Action for [repo] that runs on every PR. Use the Cortex MCP to find the services that depend on this one and their owning teams, and comment the list on the PR.
```

## Keep ownership updated

An unowned service has no one to page when it breaks. These agents keep ownership current through every reorg.

### Orphan hunter

Runs weekly. Finds services with no owner and opens a ticket for each one.

```text Prompt theme={null}
Build a weekly job that uses the Cortex MCP to list every service with no owning team, then opens a ticket for each in [Jira project], assigned to [platform team].
```

### Ownership sync

Runs nightly. Keeps Jira components, cloud tags, or routing tables in step with ownership in Cortex.

```text Prompt theme={null}
Build a nightly job that reads every service's owning team through the Cortex MCP and updates [Jira components or AWS tags] to match. Post what changed, and anything it couldn't match, to [Slack channel].
```

## Standards and reviews

Skip building the review report by hand, and get failing checks chased between reviews instead of rehashed at them.

### Ops review prepper

Runs before each review. Turns Scorecard results into a status report, so nobody builds it by hand.

```text Prompt theme={null}
Build an agent that runs every [Monday morning]. Use the Cortex MCP to pull [Scorecard] results for [teams], write a report of what's passing, what's failing and who owns each failure, and post it to [doc or channel].
```

### Fix chaser

Runs daily. Matches failing checks to the PRs fixing them and nudges the owners of everything else.

```text Prompt theme={null}
Build a daily job that pulls failing [Scorecard] rules through the Cortex MCP, checks [GitHub org] for open PRs that fix them, and messages each owning team about failures with no PR.
```

## Migrations and audits

Replace the status spreadsheet and the rounds of Slack pings with an answer pulled from every service in Cortex, current whenever leadership asks.

### Catalog auditor

Runs on demand. Asks every service in the catalog the same question and returns a table.

```text Prompt theme={null}
Build a command-line agent that takes a question like 'which services lack an OpenAPI spec?', checks every service through the Cortex MCP and writes a CSV of service, owner and answer.
```

### Migration tracker

Runs weekly during a migration. Tracks which services have moved and posts progress by team.

```text Prompt theme={null}
Build a weekly job that uses the Cortex MCP to check [custom-data key or dependency] for every service in the [migration], then posts progress by team to [Slack channel].
```

## Security

Each team running the vulnerable package gets a ticket the day the CVE drops, and scanner findings go straight to their owners.

### Finding router

Runs after each scan. Files every scanner finding with the team that owns the asset.

```text Prompt theme={null}
Build an agent that runs after each [scanner] export. Match every asset to its Cortex entity through the Cortex MCP, file each finding in [ticketing tool] for the owning team, and list assets with no match.
```

### CVE scoper

Runs when a new Common Vulnerabilities and Exposures (CVE) entry is published. Finds every affected service and opens a ticket with each owning team.

```text Prompt theme={null}
Build an agent I run with a package name and version. Use the Cortex MCP to find every service that depends on it and its owning team, then open a ticket for each team in [Jira project].
```

## Answers in chat

"Who-owns-this" questions stop landing on the platform team, and new hires get a map of their services on day one.

### Help bot

Always on in chat. Answers questions like who owns a service and how it deploys, using data from the catalog.

```text Prompt theme={null}
Build a Slack bot that answers questions about our services. For questions about ownership, deploys or docs, it searches Cortex through the Cortex MCP, answers only from what Cortex returns and links to the entity.
```

### Onboarding guide

Runs for each new hire. Sends a new engineer a tour of the services their team owns.

```text Prompt theme={null}
Build an agent I run with a new hire's team. Use the Cortex MCP to list the team's services, what each does and depends on, and how each scores, then send the new engineer a welcome guide in [Slack].
```

## Get started

[Connect the Cortex MCP](https://docs.cortex.io/get-started/cortex-ai-assistant/mcp/configuring-cortex-mcp.md) to start building, or book a build session with your Customer Success Manager (CSM).


## Related topics

- [Cortex MCP](https://docs.cortex.io/guides/product-areas/cortex-mcp.md)
- [Going further with Cortex](https://docs.cortex.io/get-started/quickstart/going-further-with-cortex.md)
- [Kubernetes](https://docs.cortex.io/ingesting-data-into-cortex/integrations/kubernetes.md)
