> ## 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.

# Composable capabilities

> Understand capability domains, provider records, pinned foundations, and how Forge resolves external dependencies.

A **capability** is a typed contract for something Forge needs from a provider: inference, embeddings, source control, notifications, file hosting, isolated compute, or another platform dependency. Callers depend on the contract rather than a vendor SDK.

A **provider record** connects one capability domain to one registered adapter. It records whether that provider is enabled, its priority, its vendor connection, and non-secret options. Secrets remain in the credential system.

## Listed does not mean configured

`CAPABILITY_DOMAINS` is the canonical domain list. A domain can be visible in Console without having an enabled provider.

Each domain's foundation-provider setting defines whether Forge pins a provider for it:

* A non-null value, such as `forge` or `vercel`, names a foundation provider. Its record is always present and is ordered after every provider an operator enables, so it serves the domain whenever no other provider is enabled.
* `null` means Forge does not pretend to supply that capability. The domain rests as **listed, unconfigured** until an operator enables a real provider.

This distinction matters for inference, embeddings, source control, organization structure, coding agents, synchronized knowledge, and other domains that cannot safely fall back to a fake internal implementation. An unconfigured domain fails with a domain-specific error; it does not silently switch providers.

## How resolution works

Each time Forge needs a capability, it reads the domain's enabled provider records, applies the domain's dispatch mode (its one active provider, or every enabled provider for a fanout domain), and builds the provider from the selected record's adapter and credential. A missing foundation record or an unconfigured domain fails explicitly; nothing falls back to a deployment-wide default.

Some calls must use the provider that stored data names rather than the domain's first provider. Those select that exact record.

## Single and fanout domains

Dispatch mode comes from `CAPABILITY_DOMAIN_METADATA`; an operator does not toggle it per deployment.

* **Single** domains use the active record. Extra enabled records are not a live retry chain.
* **Fanout** domains deliver to every enabled stateless provider and merge results according to the domain contract.

LLM model-rung fallback is a separate `llm_fallback_chains` concern. It is not provider-record failover.

## What operators configure

In **Platform → Capabilities**, operators can inspect domain readiness and provider records. Provider setup may require a vendor connection under **Platform → Vendors → Credentials**. Enabling a record does not bypass credential, scope, or runtime-governance checks at the call site.

When a capability is unavailable, first distinguish:

1. no provider records (a deployment or seeding problem);
2. records exist but none is enabled (listed but unconfigured);
3. the selected record lacks a usable credential or binding;
4. the provider call failed after resolution.

Those states require different recovery; do not add a placeholder provider merely to make resolution succeed.

## Current domain source

The current list and operator-facing descriptions live with `CAPABILITY_DOMAINS` and `CAPABILITY_DOMAIN_METADATA`. Link to those sources rather than copying a second inventory into implementation guides; the list evolves as domains are added or retired.

## Coding agent capability

The `coding_agent` capability delegates repository work to a configured coding harness in a
governed sandbox. The harness edits and tests code; Forge owns the surrounding identity,
credentials, execution lease, publication, and completion evidence.

A coding-agent provider identifies the harness, such as Claude Code, Codex, or GlooCode. It is
separate from an inference provider or model selection. Available provider configuration and
credentials determine which harness can run in a deployment.

### Execution boundary

1. An eligible Forge agent invokes `run_coding_task` from the `codingAgent` tool set with a
   repository and task specification.
2. Forge evaluates the applicable governance boundary and repository protections.
3. It provisions the sandbox and brokers the repository credential and configured inference route.
4. The harness clones, edits, tests, commits, and pushes its work under those constraints.
5. Forge publishes the pull request through the source-control capability and observes repository CI.
6. Forge records the resulting state and configured notifications. Merge authority remains a
   separate repository policy decision.

The harness's statement that tests passed is not the completion proof. The repository's CI result
supplies independent evidence. A green check also does not establish that the requested product
behavior is correct; review and acceptance criteria remain necessary.

### Credentials and network access

Repository access is brokered for the target repository rather than supplied as a broad,
long-lived organization credential. Git-host API publication belongs to the platform's
source-control boundary; the harness's repository operations use the permitted Git transport.

Inference routing is provider metadata. A harness configured for `forge_gateway` receives a
run-scoped credential for the platform inference gateway. The gateway checks the run context and
configured limits, resolves upstream credentials, and records usage. A provider-native route has its
own declared credential and egress contract; do not assume every harness uses the same wire protocol
or authentication mechanism. The run-scoped gateway is distinct from the public agents-as-models
API; see the [Inference reference](https://docs.gloo.com/forge/reference/inference.md).

### What operators verify

Before enabling a coding-agent provider, confirm its configured harness, source-control
integration, repository target, credential delivery, inference route, sandbox image, and allowed
network destinations. A listed provider is not necessarily configured or enabled.

For a failed run, inspect the stage that failed: admission, repository access, sandbox
provisioning, harness execution, publication, or CI. Do not rerun a task merely because the observer
timed out; first reconcile whether a branch, PR, or remote execution already exists.

Use [Capabilities](https://docs.gloo.com/forge/console/platform/capabilities), [Sandboxes](https://docs.gloo.com/forge/console/production/sandboxes.md),
[Runs](https://docs.gloo.com/forge/console/production/runs.md), and [Events](https://docs.gloo.com/forge/console/observe/events) for the
corresponding operator evidence. A workflow or factory using the capability still owns its business
task and recovery policy.

## Next steps

> [card] [Tools and skills](https://docs.gloo.com/forge/concepts/tool-registry.md)
>
> See how agents call operations, including capability-backed tools.

> [card] [Connect an external service](https://docs.gloo.com/forge/build/set-up-external-app.md)
>
> Configure outbound vendor credentials and bindings as an operator.

> [card] [System overview](https://docs.gloo.com/forge/architecture/system-overview.md)
>
> Place capabilities in the wider Forge runtime.

> [card] [Configure a sandbox](https://docs.gloo.com/forge/build/configure-sandbox.md)
>
> Understand the capability boundary for isolated execution.


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