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

# Coding agents overview

> Wire Ntropii into Claude Code, Copilot Studio, and other coding agents that consume MCP.

A **coding agent** is the LLM-driven environment you use to *author* runbooks: Claude Code in your terminal, Cursor in your editor, Microsoft Copilot Studio in your browser. The agent reads your codebase, calls tools, and writes code — and Ntropii is one of the tool surfaces it can call.

## Why this matters

Writing a fund-ops runbook from scratch is slow. The author needs to know:

* The exact warehouse layout (tables, columns, types) for the customer's data platform
* Which `ntro` SDK capabilities exist and how they compose
* The customer's chart of accounts, jurisdiction, and reporting obligations
* The shape of incoming documents (invoice formats, bank statement layouts, property reports)

A coding agent with MCP + CLI access to Ntropii can answer most of those questions itself:

* **`ntro://integrations/{id}/schemas`** lets it read the warehouse layout directly.
* **`ntro://tenants/{slug}`** lets it read the tenant's metadata and existing workflows.
* **`ntro_workflow_create`** lets it deploy a generated runbook to Ntropii Tenant and bind it to an entity.
* **`ntro workflow test`** (via the bash CLI) lets it run the runbook locally and iterate before deploying.

The result: a coding agent generates a working draft of a runbook in minutes, the human reviews and corrects it in a PR, the corrections feed the correction corpus, and future generations get better. This is the [compiled-agent model](/get-started/how-it-works) in practice.

## Two surfaces, both useful

<CardGroup cols={2}>
  <Card title="MCP server" icon="plug" href="/tooling/mcp-server">
    Structured tools, resources, and prompts. The agent calls `ntro_workflow_create(...)` and gets a typed response. Best for actions that need a contract.
  </Card>

  <Card title="CLI" icon="terminal" href="/tooling/ntro-cli">
    The agent runs `ntro workflow test` in a bash shell and reads the output. Best for actions where the agent wants to *see* exactly what a human would see — progress bars, scenario summaries, error traces.
  </Card>
</CardGroup>

A well-wired coding agent has both. MCP for structured calls, CLI for terminal-shaped feedback loops.

## Supported in this version

| Agent                      | Doc page                                                      | Status                                                 |
| -------------------------- | ------------------------------------------------------------- | ------------------------------------------------------ |
| Claude Code                | [Claude Code setup](/tooling/coding-agents/claude-code)       | ✅ Documented                                           |
| Microsoft Copilot Studio   | [Copilot Studio setup](/tooling/coding-agents/copilot-studio) | ✅ Documented                                           |
| Cursor                     | —                                                             | Mostly drop-in: same MCP server, different config file |
| Codex CLI                  | —                                                             | Mostly drop-in: same MCP server, different config file |
| Claude Desktop / claude.ai | [MCP server → transports](/tooling/mcp-server)                | Use Streamable HTTP transport                          |

The MCP server is the same regardless of which client you use. The only difference is *where* the client expects to find its MCP config — `~/.claude/mcp.json` for Claude Code, a Power Platform action for Copilot Studio, etc.

## Authoring loop

Once your coding agent has MCP + CLI access, the typical loop looks like this:

<Steps>
  <Step title="Describe the workflow you want">
    "Generate a monthly NAV runbook for Acme SPV 1 — pull the trial balance from Snowflake, validate journal balance, and post the result back." The agent reads `ntro://tenants/acme-fund` and `ntro://integrations/{id}/schemas` to ground itself.
  </Step>

  <Step title="The agent writes the runbook">
    Drafts `runbooks/nav-monthly-acme/templates/workflow.py` using the patterns in `runbook-templates`. References real `ntro` SDK capabilities — `data.get_data_plane`, `accounting.validation`, `accounting.proposal` — by reading the existing templates as examples.
  </Step>

  <Step title="You test locally">
    The agent runs `ntro workflow test ./runbooks/nav-monthly-acme --scenario happy` and reads the output. If a scenario fails, it iterates on the runbook.
  </Step>

  <Step title="You review and deploy">
    The agent opens a PR. You review the runbook, request changes if needed, merge. The agent (or you) runs `ntro workflow create --path ./runbooks/<slug>/ --tenant <tenant> --entity <entity>` — or asks the MCP `ntro_workflow_create` tool — to ship it.
  </Step>
</Steps>

The next two pages walk through the wiring for the two agents we currently document.