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

# Your operating model in Claude

> Read your AI Operating Model, talk through a process, and change what you own, all from a conversation in Claude.

Your [AI Operating Model](/platform/operating-model/overview) is the map of how your organization actually works, and how much of it AI could support. The connector puts that map inside Claude, so you can interrogate it, talk a process through, and keep it true, without opening the platform.

This is the biggest thing the connector does that isn't just reading programme status. **Everyone in your organization can read the whole map.** What you can *change* depends on where you sit.

## Start with the world view

```text theme={null}
How much of our business could AI support today, and where are the gaps?
```

Claude returns your unit tree with coverage rolled up on every node: coverage percentage, how many processes sit under it, how many carry a redesign gap, and how many are constrained. Rollups cover each unit's whole subtree, so a top-level number already accounts for everything beneath it.

This is the conversation to have before a steering meeting. Ask follow-ups in the same thread:

```text theme={null}
Which two functions have the worst coverage relative to their size?
```

```text theme={null}
Where do the constraints concentrate?
```

## Drill into a function

```text theme={null}
Show me Finance: its processes and where the backlog is
```

You get that unit's rollup, the processes it owns directly with their own rollups, its child units, and the **top redesign-backlog steps** across its processes, ranked by constraint and coordination burden. That ranking is the answer to "what would we fix first", computed the same way the platform computes it, so the two never disagree.

## Talk a process through

```text theme={null}
Walk me through the month-end close process
```

This is the richest response the connector gives. Claude gets:

<AccordionGroup>
  <Accordion title="The step chain">
    Every step in order, with its **current** disposition (how it's done today) and its **target** (where it should head). The distance between those two is the redesign gap, and it's what puts a step on the backlog.
  </Accordion>

  <Accordion title="The DEFINE contract on each step">
    Acceptance criteria (the bar the step's output has to meet), the input artifact, and the output artifact. This is what makes a step specifiable rather than just named.
  </Accordion>

  <Accordion title="Quality evals">
    The checks that prove a step is meeting its acceptance criteria, with target versus current scores. A **gate** blocks the step until it passes; a **monitor** samples it. This is how you answer "how would we know if the AI got it wrong?"
  </Accordion>

  <Accordion title="Connections">
    The handoffs and feeds between this process and others, projected from this process's point of view, so you can see what breaks upstream and downstream if you change it.
  </Accordion>

  <Accordion title="Initiatives already aimed at it">
    The opportunities, deliverables, and projects linked to the process, or pinned to one specific step. Useful before you raise anything: the work may already be in flight.
  </Accordion>
</AccordionGroup>

Because it's a conversation, the useful questions are the ones a document can't answer:

```text theme={null}
Which of these steps could realistically go AI-assisted this quarter,
and what would we need to prove first?
```

## Change what you own

If the map is wrong, fix it in the conversation:

```text theme={null}
Step 4 is actually done in Excel, not in the ERP. And the target
should be AI-assisted, not human.
```

Claude already knows whether you're allowed to make that change, because the process read tells it up front. So it either makes the edit, or offers to propose it, without you having to find out by being refused.

<Steps>
  <Step title="Claude checks your access">
    Every process response carries what you may do to it: edit, create, or propose.
  </Step>

  <Step title="It edits, or it offers to propose">
    If the process is yours, or sits below you in the org tree, the change lands. If not, Claude offers the proposal route instead.
  </Step>

  <Step title="You confirm">
    Nothing is written until you say so. Writes are always an explicit user action.
  </Step>
</Steps>

### The Jidoka rule

If you set a step's target to **fully autonomous**, you must also give it an escalation trigger: the stop-condition that hands control back to a human. The server rejects an autonomous step without one, so you can't accidentally describe a process where AI runs unsupervised with no defined way to stop it.

```text theme={null}
Set step 6 to AI autonomous, escalate to the controller if the
variance is over 2% or any account is unreconciled
```

### Setting the quality bar

Evals are how a business owner says what "good" means, in their own terms:

```text theme={null}
Add a gate on step 3: every categorisation has to be right,
target 100%, checked by human review
```

Once an eval exists, **its owner can keep maintaining it** even if the process sits above their altitude. A function lead can own the quality bar on a process they don't otherwise control.

## Propose a change to something that isn't yours

Most people run processes they don't own. That's normal, and the connector treats it as the common case rather than an error:

```text theme={null}
This approval step is a bottleneck and should be automated.
Raise that with whoever owns it.
```

Claude files an [Opportunity](/platform/opportunities) linked to the process, and pinned to the step if you named one. The process itself is untouched. Your proposal then shows up as an initiative against that process, so the next person who asks Claude to walk through it sees your input in context.

Anyone in the organization can propose against any process they can see.

## Who can change what

| Your relationship to the target                | What you can do                                              |
| ---------------------------------------------- | ------------------------------------------------------------ |
| You **own** it                                 | Edit in place                                                |
| It's **below** your unit                       | Edit in place, and create new processes or child units there |
| It's **at** your unit but someone else owns it | Create alongside it, propose changes to it                   |
| It's **above** you, or in an unrelated branch  | Read and propose                                             |
| You have **no home unit** set                  | Read and propose, everywhere                                 |

Admins and core team can edit anywhere in their own organization. Creating a new **root** unit reshapes the top of the org chart and is restricted to them.

<Info>
  If you should be able to edit but everything routes to a proposal, your **home unit** probably isn't set. Ask your organization admin to set it. See [ownership and governance](/platform/operating-model/ownership-and-governance).
</Info>

## What the connector won't do here

* **Delete anything.** No process, step, eval, or unit can be deleted through the connector
* **Link a process to a deliverable or project**, or wire up connections and implementation links. Those are structural edits your Kowalah team makes
* **Set Kowalah-side ownership** on anything, even on records you create
* **Approve a proposal.** Proposals land as opportunities for the owner and your Kowalah team to triage

<CardGroup cols={2}>
  <Card title="Operating model in the platform" icon="map" href="/platform/operating-model/overview">
    The full picture: the map, the cockpit, and delivery
  </Card>

  <Card title="Owning and improving a process" icon="pencil" href="/platform/operating-model/owning-and-improving">
    The same job, done in the web platform
  </Card>

  <Card title="Available tools" icon="wrench" href="/integrations/mcp/available-tools">
    Every connector tool and what it returns
  </Card>

  <Card title="Set up in Claude" icon="monitor" href="/integrations/mcp/setup-claude">
    Add the connector to your Claude workspace
  </Card>
</CardGroup>