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

# Capabilities

> The capability provider registry — every platform capability domain, the foundation provider, and the chain of operator-selectable external providers.

**Capabilities** (`/platform/capabilities`) is the operator surface for the composable capability-provider registry. Every platform-level external dependency — LLM inference, secrets, project management, org structure, embeddings, notifications, sandbox, file hosting — is served through a pluggable provider pattern. The page exposes the active chain per capability domain and lets operators reorder or disable individual providers.

![Capabilities](https://mintcdn.com/gloo-b243725a/xyq5perq6SLByPBn/forge/images/console/platform/capabilities-light.png?fit=max\&auto=format\&n=xyq5perq6SLByPBn\&q=85\&s=670f87d7927400073df959ae90f5fec0)

Capabilities — Forge Console at `/platform/capabilities`

## What you can do

* Browse every capability domain and its current provider chain.
* Inspect a chain — the operator-selectable providers and the **foundation provider** (pinned by platform code, cannot be removed).
* Add an external provider to a chain when its credentials are configured; the page surfaces what env vars the provider expects.
* Reorder providers within a chain. In a **Single** domain the enabled provider at the head of the chain is the default: it serves every call that a more specific route does not send elsewhere. Those routes are an organization binding (File hosting, Source control and Typed Judgements), a model's route (Inference), and the provider an existing item was stored with. Forge does not fail over to the next entry when the provider errors. In a **Fanout** domain every enabled provider whose credential resolves receives the call; one that fails to resolve is left out and logged.
* Disable an external provider without removing it; disabled providers stay in the chain for audit but receive no traffic.
* Inspect Slack workspace installations by connection and workspace ID, including provider health
  and the credential binding used at runtime. Slack appears within each capability it provides
  rather than as a vendor-owned parallel subsystem.
* Inspect GitHub's distinct `rest`, `graphql`, and `mcp` connection surfaces. A provider that needs
  REST and GraphQL resolves both credentials independently; Forge does not copy a token from one
  connection into another. The retired `api` connection is not a compatibility fallback.
* Provider credential rows appear only when you hold `credentials:read` at that Credential's
  scope. Provider resolution remains visible without those rows. Provider options reject
  secret-shaped keys and values; store secrets as Credentials on the vendor Connection.

> [!NOTE]
>
> In a Single domain the chain editor's mode line reads "remaining entries are fallback on error", the
> chain list labels every entry after the first "Fallback", and the foundation's lock icon reads
> "Always at head of chain". At runtime none of these holds: no entry takes over when the head
> provider errors, and the foundation sorts after the other enabled providers.

## Key state to watch

* **Foundation provider** — usually `forge` (Convex-native). For `sandbox` it's `vercel` since there is no Convex-native VM.
* **Which provider serves.** Enabled providers are ordered by priority, and the pinned foundation sorts after them, so it is a Single domain's default only when no other provider is enabled. A failing head provider is not skipped: fix or disable it.
* **Slack installation health** — a usable installation has one active connection, one Slack team
  identity, and one exact `slack/bot` Forge Credential with matching org-unit scope. That single
  connection-linked credential serves notifications, human interaction, chat syndication, publish,
  and org structure; capabilities do not create or select their own Slack credentials. Missing,
  ambiguous, revoked, expired, unhealthy, or cross-scope bindings fail closed.
* **Slack live verification** — **Verify workspace** calls Slack `auth.test` through the exact
  connection-linked credential and validates both workspace and bot identity. The Vendor detail
  shows the same credential as **Slack OAuth managed**; token lifecycle is managed from this
  workspace surface rather than edited on the Vendor page.
* **SendGrid credential health** — one system-scope `sendgrid/api` Forge Credential serves the
  three SendGrid providers: notifications (`email` channel), human interaction (email replies), and
  publish (the `email` destination). Each provider record ships disabled. The healthcheck reads
  SendGrid `/v3/scopes` with that Credential's key: healthy when `mail.send` is granted, down when
  no Credential resolves or `mail.send` is missing, and degraded `credential_present` when SendGrid
  refuses the scopes read.
* **GitHub credential health** — provision and verify token-backed credentials separately for
  `github/rest`, `github/graphql`, and `github/mcp`. The source-control and project-management
  providers require both REST and GraphQL to resolve; a missing surface fails closed and remains
  visible as not provisioned.

## Typed Judgements organization readiness

For `typed_judgments`, select the organization on the capability detail page and inspect
**Organization readiness**. You need `credentials:read` at that organization to read this scoped
projection. It checks the organization's provider binding, the enabled TypeSafe provider, and the
approved production Credential elected for `typesafe/typed-judgments` at that exact organization.
The Credential must have its API key provisioned. A system Credential or another organization's
Credential does not satisfy this check.

**Ready** means those dependency records are configured. It does not probe the TypeSafe API key
or grant a workflow permission. A **Not ready** explanation identifies the missing binding,
disabled or mismatched provider, or missing production Credential. Fix the corresponding record
on the existing capability or [Vendor connection](https://docs.gloo.com/forge/console/platform/vendors) surface. Secrets
and credential identifiers are not included in this readiness response.

Capability enablement and deployment-level provider health remain separate. An organization can
have the correct Credential while a system connection is unconfigured; that is not a reason to
copy its key into a system Credential. The organization's readiness also requires its selected
provider to be enabled.

Before publishing, Forge checks the pinned typed procedure's declared capability, connection,
`procedures:use`, and external-delivery declaration, its bounded organization bindings and planned
workflow-version acting-for authority. Publication refuses missing dependencies rather than
publishing a version that cannot use them. Procedure metadata reads select and cache exact pinned
versions, including the legacy lookup path; unavailable metadata blocks publication.

At execution, the governed procedure proxy rechecks current persisted identity and authority before
credential resolution or TypeSafe delivery. Revoking a published version's grant prevents a
retained signed invocation from using it. Published version authority remains distinct from the
person authority used for attributable draft or debug execution.

## Related

* [Capability Architecture](https://docs.gloo.com/forge/concepts/capabilities.md)
* [Capability Inventory](https://docs.gloo.com/forge/concepts/capabilities.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.