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

# Overview

<Note>
  This feature is currently in private beta. [Contact us](https://www.stigg.io/contact) to join.
</Note>

Stigg Governance lets your enterprise customers control AI usage and credit spend across their organizations. Teams, departments, individual users, and AI agents each get their own budgets and limits — enforced in real time, with full visibility into who's consuming what.

## Availability

<CardGroup cols={2}>
  <Card title="Private beta" icon="lock">
    **[Contact us](https://www.stigg.io/contact) to join.**

    * Create entity types and hierarchies
    * Hard limits for credits and metered features
    * Visibility and sorting across all entities and cardinalities
  </Card>

  <Card title="Early access" icon="rocket">
    **[Contact us](https://www.stigg.io/contact) to join.**

    * Allocated budgets per entity
    * Soft limits
    * Alerts
  </Card>
</CardGroup>

## The problem

Enterprise customers adopting AI features face a critical governance challenge: uncontrolled AI usage and spend.

Without proper controls:

* Individual users or agents can exhaust shared credit pools
* Finance teams lack visibility into departmental consumption
* IT admins cannot enforce cost boundaries across teams
* Usage spikes cause unexpected billing surprises

## What you can build

| Capability                          | Description                                                                                                                          |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| **Hierarchical budgets and limits** | Distribute credits or restrict usage across complex org structures at any level — organization → department → team → user → AI agent |
| **Real-time enforcement**           | Block operations the moment a limit is reached, with sub-millisecond check latency that doesn't add delay to product flows           |
| **Automatic cost attribution**      | A single usage event updates balances at every level of the hierarchy simultaneously — no need to report usage multiple times        |
| **Visibility and reporting**        | Query the full governance tree sliced by entity type, capability, or utilization to power dashboards and admin UIs                   |
| **Self-service management**         | Embed a governance interface so your customers' admins can allocate budgets and set limits without involving your team               |
| **Slippage controls**               | Set hard limits that block on breach, or soft limits that allow overage and trigger alerts                                           |

## How it works end to end

```mermaid theme={null}
sequenceDiagram
    participant Vendor
    participant Customer
    participant GovernanceAPI
    participant YourApp

    Vendor->>GovernanceAPI: Define entity types (org, team, user, agent…)
    Vendor->>GovernanceAPI: Provision entities per customer
    Customer->>GovernanceAPI: Set budgets and limits
    YourApp->>GovernanceAPI: Check (before consuming)
    YourApp->>GovernanceAPI: Ingest (after consuming)
```

1. **You** define the entity types once per environment — for example `org`, `team`, `user`, `agent`.
2. **Your backend** provisions entity instances for each customer as they are created in your product (their org structure, team members, AI agents). This is a vendor-side operation, not customer-driven.
3. **Your customers** set the actual budgets and limits through an in-app interface you build.
4. **Your application** calls [Check](/documentation/governance/check-and-ingest#check) before any governed action and [Ingest](/documentation/governance/check-and-ingest#ingest) to record consumption.

## Governance is opt-in

If an entity has no assignment, the Check endpoint grants access. You can roll out governance incrementally — ungoverned entities continue to work exactly as before.

## Next steps

<CardGroup cols={2}>
  <Card title="Core concepts" icon="book" href="/documentation/governance/core-concepts">
    Understand entity types, entities, assignments, and the hierarchy model
  </Card>

  <Card title="Setting up governance" icon="gear" href="/documentation/governance/setting-up">
    Step-by-step guide to configuring entity types, entities, and assignments
  </Card>

  <Card title="Check and ingest" icon="bolt" href="/documentation/governance/check-and-ingest">
    Integrate the runtime check and ingest endpoints into your application
  </Card>

  <Card title="Query the governance tree" icon="chart-bar" href="/documentation/governance/query">
    Fetch usage and budget data for dashboards and admin UIs
  </Card>
</CardGroup>