Adapter Integration
FORG adapters connect your editor, AI coding assistant, CLI, or internal agent to the local FORG agent. Each adapter hooks into the tool's native extension or hook system, emits structured signals after every AI interaction, and receives budget responses where applicable — without capturing any prompt or completion text.
What is an adapter?
An adapter is the integration layer between an AI coding tool and the FORG agent. It hooks into adapter-specific integration points — hooks files, MCP settings, workspace tasks, Lua autocommands, or system prompt injections — and communicates session events (tool calls, session boundaries, token counts) to the forg binary over 127.0.0.1:6247.
Adapters operate on the same open protocol: a JSON POST to the local agent, signed with an HMAC session key, followed by a synchronous budget response where applicable. If the agent is not running, adapters fail open so your workflow is never interrupted.
Session lifecycle, tool calls, token budgets, and cost attribution for Claude Code.
MCP server registration in Cursor for tool-call signals and session boundaries.
MCP server registration in VS Code settings for tool-call signals and session boundaries.
MCP server registration in Windsurf for tool-call signals and session boundaries.
MCP server stub for JetBrains IDEs — operator copies into plugin.xml to enable tool-call signals.
Native hook integration for OpenCode sessions, tasks, and tool usage.
Native hook integration for Pi agent sessions, tasks, and tool usage.
Lua plugin telemetry for AI-assisted terminal-native workflows.
Copilot completions, Copilot Chat, seat utilization, and ROI measurement.
Open-source AI coding assistant telemetry across VS Code and JetBrains.
MCP server registration in ~/.codex/config.yaml for Codex CLI session telemetry.
MCP server registration in ~/.gemini/settings.json for Gemini CLI session tracking.
Pair-programming session telemetry for Aider workflows via AGENTS.md injection.
MCP server registration in Zed settings for AI workflow telemetry.
MCP server registration in ~/.warp/mcp_config.json for Warp terminal AI sessions.
PowerShell profile injection to expose forg-mcp as a shell function.
Sessions emitted directly via the forg CLI without a named adapter.
MCP integration for Amazon Kiro AI IDE sessions and tool usage.
MCP integration for Trae AI IDE (ByteDance) sessions.
MCP integration for Void open-source VS Code fork sessions.
MCP integration for Plandex CLI coding agent sessions.
MCP integration for Sourcegraph Amp CLI sessions.
MCP integration for PearAI IDE sessions.
MCP integration for Aide (Codestory) IDE sessions.
MCP server registration in ~/.supermaven/mcp.json for code-completion telemetry.
MCP server registration in ~/.sourcegraph/cody/mcp.json for Cody workflows.
MCP server registration in ~/.qodo/mcp.json for Qodo IDE agent sessions.
MCP server registration in ~/.tabnine/mcp.json for Tabnine assistant telemetry.
Amazon Q usage visibility for AWS-heavy engineering teams.
Cody chat and code intelligence session metadata.
Tabnine usage telemetry for completion-heavy teams.
Supermaven completion metadata and developer workflow attribution.
Emit FORG signals from Replit-based AI build sessions.
Protocol path for autonomous software-engineering agent telemetry.
Augment Code usage telemetry for enterprise codebase assistants.
Testing and code-quality assistant telemetry.
Pull-request AI review events through protocol integration.
Browser-based build-agent sessions through protocol events.
App-builder AI workflow telemetry through the open protocol.
Design/build generation telemetry for v0-style workflows.
MCP server registration in ~/.roo/mcp_settings.json for Roo Code agent workflows.
MCP server registration for Cline agentic VS Code sessions, tool calls, and model usage.
Local agent session telemetry for Goose workflows.
Multi-agent workflow telemetry through custom protocol events.
Graph-based agent run metadata and outcome tracking.
Agent conversation metadata for AutoGen workflows.
Internal AI agents can emit FORG signals with a signed HTTP POST.
Emit AI-job telemetry from scripts, CI pipelines, and automation.
Proxy-level session capture for any LLM request routed through the gateway.
Import historical usage data from OpenAI, Anthropic, or generic CSV.
Automatic daily sync of usage data from stored provider API keys.
Browser extension captures Claude web sessions with real-time heartbeat tracking.
MCP server registration in Claude Desktop for native app session tracking.
Protocol integration for OpenHands (formerly OpenDevin) autonomous coding agent.
Protocol integration for Google Jules async coding agent.
Protocol integration for Firebase Studio (Google's cloud AI IDE).
Protocol integration for Sweep AI automated PR agent.
Protocol integration for GitHub Spark AI micro-app builder.
Browser extension captures ChatGPT web sessions with real-time heartbeat tracking.
Open protocol documentation. Any tool that can make HTTP requests can be a FORG adapter.
Claude Code
The Claude Code adapter installs FORG-managed hooks into ~/.claude/settings.json so session boundaries, tool calls, and token metadata emit directly through forg emit.
It is the lowest-latency path in the catalog because Claude Code calls FORG from native hook events instead of going through MCP.
forg connect claude-codeCursor
Cursor uses native MCP registration, so FORG shows up alongside your other MCP servers with no project-level FORG files to maintain.
Once connected, Cursor sessions, tool activity, and model usage flow into the same FORG timeline as every other supported editor.
forg connect cursorVS Code
The VS Code adapter registers forg-mcp in VS Code's MCP settings so AI sessions can be attributed without adding an extension-specific FORG plugin.
It works well for mixed environments where the same team uses Copilot, Continue, Cline, and internal MCP-aware workflows inside VS Code.
forg connect vscodeWindsurf
Windsurf connects through MCP and gives FORG visibility into Cascade sessions, tool use, and model-level cost allocation.
Use it when you want the same governance surface across Windsurf and the rest of your AI coding stack.
forg connect windsurfJetBrains
JetBrains IDEs connect through an MCP configuration path that works across IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, and the rest of the IntelliJ family.
FORG keeps the install idempotent so teams can standardize the same connection flow across multiple IDEs on one machine.
forg connect jetbrainsOpenCode
The OpenCode adapter uses OpenCode's native MCP config so session lifecycle, task tracking, and tool-use metadata appear in FORG automatically.
It's the fastest way to bring terminal-native OpenCode sessions under the same budgets and alerts as your editors.
forg connect opencodeNeovim
Neovim uses a Lua plugin file generated by FORG, giving you terminal-native session telemetry without wrapping your editor startup command.
The adapter is especially useful when teams mix Neovim with MCP-based tools and still want one dashboard and one budget surface.
forg connect neovimGitHub Copilot
The Copilot adapter uses MCP so Copilot-enabled workflows can report session metadata, model usage, and cost allocation into FORG with the same one-command install flow.
That makes Copilot seat usage visible next to Claude Code, Cursor, and every other officially supported adapter.
forg connect copilotContinue
Continue also connects through MCP, which makes it easy to track provider-agnostic sessions even when teams swap between Anthropic, OpenAI, Gemini, or local models.
FORG keeps the attribution and budget layer consistent regardless of which underlying model Continue routes to.
forg connect continueOpenAI Codex CLI
The Codex adapter writes a FORG MCP server entry into ~/.codex/config.yaml so Codex CLI sessions are visible without custom wrapper scripts.
It is a clean fit for terminal-first teams that want session telemetry, model usage, and cost tracking from Codex alongside Claude Code and Gemini CLI.
forg connect codexGemini CLI
Gemini CLI uses MCP registration, giving Google Gemini sessions the same telemetry path, dashboards, budgets, and alerts as the rest of the FORG adapter catalog.
It is especially useful for teams comparing Gemini usage against other providers in one shared budget surface.
forg connect gemini-cliAider
Aider does not expose native MCP support today, so FORG injects a managed context block into ~/AGENTS.md so pair-programming sessions are still attributed correctly.
For full signal tracking during terminal use, run forg on before launching Aider so your shell session is already under FORG observation.
forg connect aiderWarp Terminal
Warp uses MCP config registration, letting FORG observe Warp's AI-assisted terminal workflows without changing how developers open or use Warp.
That makes Warp a good bridge between shell-native workflows and the rest of your editor-based adapter fleet.
forg connect warpCline
Cline connects through MCP so agentic VS Code sessions, tool calls, and session boundaries are visible in FORG immediately after setup.
Teams using Cline for longer-running task execution can keep the same budget enforcement and recording they use everywhere else.
forg connect clineRoo Code
Roo Code uses the CLI slug roo while the catalog slug remains roo-code, and FORG handles that mismatch for you during connection.
The adapter exposes Roo's model telemetry and tool metadata through MCP so agent workflows in VS Code land in the same FORG timeline as Cline and Continue.
forg connect rooZed
Zed registers forg-mcp in its settings so AI-assisted editing sessions can be recorded without custom project files or editor wrappers.
Once connected, Zed activity participates in the same dashboards, budgets, alerts, and cost reporting as other official adapters.
forg connect zedPowerShell
The PowerShell adapter injects a managed forg-mcp function into your PowerShell profile so FORG is ready anywhere PowerShell starts.
It is the cleanest path for Windows-heavy teams that want shell-native MCP access without manual profile editing.
forg connect powershellAdapter slots by plan
Each plan allows a different number of simultaneously active adapters (adapter slots).
| Plan | Active adapter slots |
|---|---|
| Solo | All official adaptersCanonical Solo |
| Team | All official adaptersCanonical Team |
| Enterprise | UnlimitedCustom |
Connect as many official adapters as you need with forg connect <name>. Grandfathered Free accounts are limited to one active adapter at a time; switching deactivates the previous one.
How adapters work
All adapters communicate with the local FORG agent over HTTP on 127.0.0.1:6247. The agent:
- Validates the signal with HMAC-SHA256 using a per-session key
- Applies opt-in gateway hard-blocks when a budget is exceeded
- Buffers the signal and forwards it to FORG at
forg.pro/engine/v1 - Returns a response indicating whether the signal was accepted or blocked
If the local agent is not running, adapters fail open — the AI tool call proceeds normally and the signal is dropped. This ensures FORG never interrupts your workflow.