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

# Built-in Tools

> What a connected MCP client can do with your Logic agents

## Overview

Every Logic MCP connection provides a set of **built-in tools** that let a connected AI client discover, run, inspect, and even build your Logic agents on your behalf — without switching back to the Logic dashboard.

Your agents aren't exposed as individual client tools. Instead, a client reaches them through these built-in tools — for example, **Logic: List Agents** to find an agent and **Logic: Call Agent** to run it.

In your client, the built-in tools appear at the top of the list with a `Logic:` prefix (for example, **Logic: List Agents**). Under the hood each has a raw tool ID — some clients and logs show that instead — so the entries below pair the display name with its ID.

What a client can do depends on the **permission** you give the MCP server when you create or edit it:

| Permission       | What a client can do                          |
| ---------------- | --------------------------------------------- |
| **Execute only** | Discover, run, and inspect existing agents    |
| **Author**       | Everything above, plus create and edit agents |

<Info>
  Creating and editing agents is only available on servers set to **Author**
  permission. A server set to **Execute only** can read and run your agents but
  can't change them — Logic enforces this on the server, no matter what the
  client requests.
</Info>

## Read & execute

Available on every connection:

* **List agents** (`_logic_list_agents`) — see all your agents, including drafts. This is how a client discovers what's available to run; newly created or edited agents show up here immediately.
* **Read an agent** (`_logic_read_agent`) — view its spec, the input it expects, and every way it can be triggered (email address, REST endpoint, MCP server, and schedules).
* **View executions** (`_logic_view_executions`) — review recent runs and their results to see what succeeded or failed, and why.
* **Call an agent** (`_logic_call_agent`) — run any agent by name. Since agents aren't exposed as individual tools, this is how a client executes them. Runs are asynchronous, so the client polls **Check execution status** (`_logic_check_execution_status`) until the result is ready — see [Asynchronous Task Execution](/mcp/async-tasks).

<Note>
  Runs are asynchronous, so a result isn't always instant — the assistant checks
  back on its own (by polling `_logic_check_execution_status`) until the run
  finishes, which can take a few minutes for longer workflows. An **Execute
  only** server sees only the runs it started; an **Author** server sees all of
  an agent's runs.
</Note>

## Authoring

Available on servers set to **Author** permission:

* **Create an agent** (`_logic_create_agent`) — turn a title and a spec into a new agent.
* **Edit an agent** (`_logic_patch_agent`) — update an existing agent's spec with targeted find-and-replace edits, and optionally rename it.

New and edited agents are saved as a **draft** by default. The client can publish in the same step to make the agent **live** and callable right away; otherwise your published version keeps running unchanged until you choose to publish.

<Note>
  When the assistant creates or publishes an agent, it's available right away —
  it shows up in **Logic: List Agents** immediately and can be run with **Logic:
  Call Agent**, with no need to reconnect or restart the client.
</Note>

## Next Steps

* [Agent Scope](/mcp/agent-scope) — control which agents a server exposes
* [Asynchronous Task Execution](/mcp/async-tasks) — how long-running results come back
* [Connect to an AI platform](/mcp/quick-start#step-4%3A-connect-to-an-ai-platform)