MCP Agent Skill

Open-source agents do not have Medialyst's internal workspace-agent prompt. They need a small bootstrap so they know how to connect, what the table model means, and when to ask the MCP server for current instructions.

Do not package full schemas into the skill. The MCP server owns those through get_usage_guide and get_tool_reference.

What Belongs In The Skill

Include	Why
Endpoint and auth format	The agent has to connect before it can learn anything else
Required scopes	Users can create the smallest useful API key
First-call protocol	Agents learn to ask the server for the current guide
Table mental model	Media lists are workflow tables, not free-form notes
Safety rules	Prevent accidental deletes and stale-ID mutations
Durable recipes	Give agents a small path through common tasks
Link to public docs	Humans need setup and troubleshooting context

What Stays At Runtime

Keep on the MCP server	Why
Full tool schemas	They change with the live contract
Table-action details	This is the largest drift risk
Error recovery details	Server behavior should explain itself
Examples for each tool	They should track current schemas
Scope requirements	The server can report exactly what each tool needs

Skill Template

Save this as SKILL.md in the agent's skill/plugin format.

---
name: medialyst-mcp
description: Use when working with Medialyst media lists through the remote MCP server. Helps agents create, inspect, mutate, and share media-list tables safely.
---

# Medialyst MCP

Use the Medialyst MCP server when the user wants to search news, create a media list, inspect or update a media-list table, add rows or columns, manage views, or create a share link.

## Connection

Production MCP endpoint:

```text
https://medialyst.ai/api/mcp
```

Send the user's Medialyst API key on every request:

```text
Authorization: Bearer <MEDIALYST_API_KEY>
```

Recommended scopes:

- `news:search`
- `media_lists:read`
- `media_lists:write`

## First Call Protocol

After connecting, call:

```json
{
  "tool": "get_usage_guide",
  "arguments": {
    "topic": "getting_started",
    "detail": "short"
  }
}
```

Before using an unfamiliar tool or after a validation error, call:

```json
{
  "tool": "get_tool_reference",
  "arguments": {
    "tool_name": "<tool_name>",
    "detail": "full"
  }
}
```

Set `include_schema: true` only when examples are not enough.

## Mental Model

- Media lists are workflow tables.
- The table is the deliverable.
- Rows usually represent candidate articles or journalists.
- Columns hold source data, enrichment, formulas, views, and outreach prep.
- Most edits go through `apply_table_action`.

## Safety Rules

- Inspect a table before mutating it.
- Use IDs returned by Medialyst tools. Do not invent media-list, row, column, or view IDs.
- Apply one focused mutation at a time.
- Verify mutations with `get_media_list` or `inspect_table`.
- Preview formula, AI, send, or template-bearing columns before applying them.
- Do not delete a media list unless the user explicitly asked for deletion or cleanup.
- Do not create public share links unless the user asked to share.
- Keep API keys in environment variables or client secret storage. Never paste raw keys into a prompt or commit them.

## Common Recipes

Create a new list from fresh coverage:

1. `get_usage_guide`
2. `search_news`
3. Select relevant article results.
4. `create_media_list` with `source.type = "articles"`.
5. `inspect_table` to verify rows and discover IDs.

Update an existing list:

1. `list_media_lists` or use the user-provided list ID.
2. `get_media_list` or `inspect_table`.
3. `get_tool_reference` for `apply_table_action`.
4. `apply_table_action`.
5. Verify the result.

Share a shortlist:

1. Inspect the table.
2. Create or activate a saved view with `apply_table_action`.
3. Call `create_share_link` with `view_id`.
4. Return the URL.

## Human Docs

Public docs:

```text
https://medialyst.ai/docs/developers/mcp
```

Why This Stays Small

The skill is intentionally a bootstrap. If we improve table actions, add tools, rename fields, or tighten validation, agents should learn that from the server at runtime instead of carrying stale local instructions.

The server is the manual

Open-source agents should treat get_usage_guide and get_tool_reference as part of the workflow, not as optional help text.