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

# Architecture

> How Forge discovers AI, routes traffic, and enforces policy across the enterprise.

Forge turns your existing network into an agentless control point for AI. A
firewall, SASE platform, or secure web gateway can automatically route selected
AI traffic through Forge, where the LLM Gateway and MCP Gateway apply policy
without requiring users to reconfigure their applications or install software
on every device.

The same policy and evidence model also covers native network controls,
explicitly configured gateways, and Forge on managed devices. You can use one
deployment model or combine them to match how your organization works.

## Choose a deployment model

| Deployment model               | Best for                                                                            | Customer experience                                                                                      | Forge provides                                                                                   |
| ------------------------------ | ----------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Agentless network routing**  | Organization-wide coverage through a firewall, SASE platform, or secure web gateway | Supported AI traffic is routed automatically; users keep using their existing applications and workflows | Content-aware policy through the LLM and MCP Gateways, session evidence, and centralized control |
| **Native network enforcement** | Broad allow and block controls at the network edge                                  | Traffic stays on its existing network path                                                               | Policies compiled to the network platform, plus inventory and access evidence                    |
| **Forge on managed devices**   | Off-network devices, local applications, and endpoint attribution                   | Supported traffic is routed automatically from enrolled Windows and macOS devices                        | Gateway enforcement, device health, local AI inventory, and Fleet operations                     |
| **Explicit gateways**          | Developer APIs, services, and MCP clients that can be configured directly           | Applications use an organization gateway endpoint                                                        | Central credentials, model and tool access, budgets, policy, and observability                   |

Agentless network routing is the recommended starting point when supported
traffic already passes through a compatible network platform. Forge on managed
devices extends that coverage beyond the corporate network, while explicit
gateways give application owners direct control over integrations.

## Agentless network routing

Forge works with your network platform to identify selected AI destinations and
route their traffic to the appropriate Forge Gateway. Users continue to access
ChatGPT, Claude, Gemini, coding agents, model APIs, and MCP tools through their
usual interfaces.

```mermaid theme={"system"}
flowchart LR
  USERS["Users and workloads"] --> NETWORK["Firewall, SASE, or SWG"]
  NETWORK -->|"Selected AI traffic"| FORGE["Forge routing"]
  FORGE --> LLM["LLM Gateway"]
  FORGE --> MCP["MCP Gateway"]
  LLM --> AI["AI services and models"]
  MCP --> TOOLS["Approved MCP servers"]
  LLM --> EVIDENCE["Sessions, policy, and audit"]
  MCP --> EVIDENCE
```

Forge recognizes the destination and protocol, evaluates the request with the
user's identity and your policies, and forwards allowed traffic to the original
service. The organization chooses which destinations are routed and manages
certificate trust through its existing TLS-inspection process.

This provides content-aware enforcement without installing Forge on each
endpoint or asking teams to replace their existing AI tools.

## Native network enforcement

Forge can also compile Access policies directly to a connected firewall, SASE
platform, or secure web gateway. These controls cover the broader catalog of AI
applications and enforce access at the network edge without redirecting content
to Forge.

Native enforcement and agentless routing complement each other: use native
controls for broad application access, then route selected traffic when you
want content-aware policy, detailed sessions, or MCP tool governance.

## Forge on managed devices

Forge on devices extends governed routing to enrolled Windows and macOS
endpoints, including devices away from the corporate network. It also connects
traffic to the initiating device and process, discovers local AI products and
configuration, and supports health and lifecycle operations through Fleet.

Administrators choose which devices use managed routing. Supported desktop,
browser, developer API, and MCP traffic is sent to the same LLM and MCP
Gateways used by agentless network routing. Other traffic keeps its normal
route. See [Forge for devices](/integrations/device-agent) for setup.

## Explicit gateways

Applications and workloads can connect directly to the LLM Gateway or MCP
Gateway. This model is useful for developer APIs, shared services, and MCP
clients whose endpoints are centrally configured.

The LLM Gateway manages provider access, models, budgets, and content policy.
The MCP Gateway controls which servers and tools each user or workload can
access. Both produce a consistent session and audit trail alongside traffic
routed from network and device control points.

## Shared policy and evidence

Every deployment model connects to the same Forge control plane. Forge combines
identity, application, device, and configuration context from connected
enterprise systems, then uses that context across policy, investigations, and
operations.

```mermaid theme={"system"}
flowchart LR
  SOURCES["Identity, SaaS, cloud, endpoint, and network"] --> CONTEXT["Inventory and identity graph"]
  CONTEXT --> POLICY["Policy"]
  POLICY --> CONTROL["Network, device, LLM, and MCP controls"]
  CONTROL --> OUTCOMES["Sessions, investigations, audit, and analytics"]
```

Source records retain their origin and observation time as Forge correlates
identities, devices, applications, workloads, and sessions. Sensitive session
content follows the organization's evidence-retention settings, and secrets are
resolved only by authorized collectors and runtime components.

Review [LLM Gateway](/secure/llm-gateway), [MCP Gateway](/secure/mcp-gateway),
[Privacy](/secure/privacy), and [Audit Log](/secure/audit-log) for the controls
that apply across these deployment models.
