AI Coding Agents Overview
Forge delegates AI-assisted software development work to external coding agents. An agent is the provider-specific application that receives a prompt, uses development tools, and returns a result to Forge.
Forge is the coordination layer around those agents. It supplies project and work-item context, selects prompts and models, manages sessions, validates results, controls workflow transitions, and records execution details. Forge does not provide the model service, provider account, subscription, or credentials.
Supported Agents
The active Forge agent registry supports these coding agents:
GitHub Copilot is the fallback default when Forge cannot resolve another configured default. A project can select any of the registered agents, and workflow operations can apply agent-specific choices where appropriate.
How Forge Uses an Agent
Forge and the selected agent have distinct responsibilities during an operation:
- Forge identifies the workflow operation, role, project, and relevant issue, pull request, ticket, or repository context.
- Forge composes the prompt and includes relevant files, directories, project metadata, instructions, and execution options.
- The agent interprets the prompt, uses its own tools, and performs the requested analysis or changes.
- Forge captures the response, exit status, errors, and usage information when available.
- Workflow checks determine whether the process should continue, retry, pause for approval, or finish.
This separation allows the same engineering process to work with different providers. A code review workflow, for example, can retain its checks, approval points, and traceability regardless of which supported agent performs the review.
Shared Agent Functionality
Forge integrates agents through a common interface. The interface gives Forge a consistent way to:
- Identify the provider with a stable name.
- Locate and verify the provider executable.
- Check provider authentication.
- Validate provider-specific execution options.
- Send prompts and model selections.
- Capture standard output, standard error, exit status, and token usage when available.
- Create or continue agent sessions.
- Stream output during execution when the provider supports streaming.
- Detect likely authentication failures and return provider-specific diagnostics.
When streaming is unavailable, Forge collects the complete response after the agent finishes. The workflow still receives a final result and applies the same validation and transition rules.
Agents and Models
An agent is the external application that executes a prompt. A model is the model selected by that application to reason about and perform the work. One agent can expose multiple models, and different agents can use different model names and selection rules.
Forge validates model names and formats where possible, but a valid-looking model name does not guarantee that the external provider offers the model or that the current account can use it. The selected agent and provider remain responsible for model availability, access, and pricing.
Model Profiles
Forge provides four profiles for balancing cost, speed, predictability, and quality:
| Profile | Intended balance | Typical use |
|---|---|---|
lite | Lower cost and faster responses | Routine work, experimentation, and simple changes |
balanced | Capability and cost | General development and everyday workflows |
stable | Predictable behavior | Teams that value consistency and conservative defaults |
heavy | Maximum quality and reasoning effort | Critical planning, difficult reviews, and high-risk changes |
Profiles are agent-specific mappings, not universal model names. The same profile may select different models for GitHub Copilot, OpenCode, and Claude Code because each provider has its own model catalog and execution behavior.
The generated configuration uses the stable profile by default. The default model varies by agent and profile:
| Agent | Stable default model | Profile defaults |
|---|---|---|
| GitHub Copilot CLI | claude-sonnet-5 | Lite: gpt-5.4-mini; Balanced: gpt-5.4; Stable: claude-sonnet-5; Heavy: gpt-5.5 |
| OpenCode CLI | auto | Lite: auto; Balanced: auto; Stable: auto; Heavy: auto |
| Claude Code CLI | claude-sonnet-5 | Lite: claude-haiku-5; Balanced: claude-sonnet-5; Stable: claude-sonnet-5; Heavy: claude-opus-5 |
GitHub Copilot
The GitHub Copilot profile mappings use GPT and Claude model families. Lower-cost profiles use a lighter default and promote selected planning or review operations to a stronger model. Balanced profiles use a standard default and stronger models for selected issue and pull request operations. Stable profiles favor predictable Claude behavior, while heavy profiles use a higher-capability model broadly.
Forge checks model names for structural safety, not against a vendor-maintained catalog. GitHub Copilot or another agent CLI determines whether the selected model is available. See AI Model Selection for the validation rules.
OpenCode
OpenCode supports multiple model providers. Forge's generated OpenCode profiles use the provider-neutral auto value by default and allow OpenCode to resolve the provider and model according to its own configuration.
This gives teams provider flexibility, but model quality, cost, and routing behavior depend on the OpenCode configuration outside Forge.
Claude Code
Claude Code profiles use Anthropic model names. Lower-cost profiles favor a faster model for routine work and use a stronger model for selected planning and review operations. Balanced and stable profiles use Claude Sonnet by default and reserve Claude Opus for selected high-value work. Heavy profiles use Claude Opus broadly for critical operations.
Model Resolution
Forge can select a model at several levels of specificity. The most specific applicable value takes precedence:
- An operation-specific model, such as one assigned to issue planning.
- A target-specific model, such as one assigned to all code operations.
- The selected agent's default model.
- The external agent's own default behavior when Forge has no model selection.
A one-time execution choice can override the configured levels for a single operation. This lets teams keep predictable defaults while using a more capable model for an unusually complex plan or review.
Custom Agents and Prompt Formats
Some providers support named custom agents or personas. When supported, Forge can pass a selected custom agent at the agent, target, or operation level. The custom agent may add provider-specific instructions, tools, or behavior, while Forge continues to control the surrounding workflow and project context.
Forge can compose prompts in XML or Markdown formats. Prompt format controls how instructions are packaged for the provider and model; it does not change the purpose of the workflow or its approval and validation controls.
Sessions and Context Continuity
Forge uses sessions to preserve useful continuity across related operations. A workflow can share a session when a later stage benefits from earlier reasoning, or clear the session when a fresh context is safer or more effective.
Long-running workflows can refresh context periodically to control prompt size and reduce stale assumptions. This balances continuity with predictable resource use.
Authentication and Health Checks
Forge can verify that the selected agent executable is present and that the provider can accept an authenticated request. Each agent implements its own checks because authentication behavior differs between providers.
Authentication status is separate from model availability. A provider can be authenticated while a requested model is unavailable, and a valid model selection cannot compensate for a missing or expired provider login.
Autonomous Execution and Safety
Forge runs supported agents in headless, autonomous workflows. Depending on the task, an agent may read files, execute development commands, modify the repository, create commits, interact with external services, and return changes without an individual confirmation for every action.
Use isolated development environments and review agent output, generated files, commits, pull requests, and workflow artifacts before accepting or merging changes. Forge's approval gates, checks, prompt-safety controls, and trace records provide important controls, but they do not replace human judgment.
Choosing an Agent
Choose the provider that best matches the accounts, models, tools, and governance already approved for the team:
- Choose GitHub Copilot CLI when the organization is centered on GitHub and wants GitHub-hosted or bring-your-own-key model options.
- Choose OpenCode CLI when multi-provider flexibility and provider-controlled model routing are important.
- Choose Claude Code CLI when direct Anthropic access and Claude-oriented model profiles are preferred.
Regardless of provider, Forge preserves the same workflow concepts: context-aware prompts, roles, model selection, validation, approval, recovery, streaming, and traceability.