The agent execution layer for TeamSpec. Forge reads configs from AgentHub, spawns agents against those configs, runs them through their task lifecycle, and records what happened — with full observability built in from the start.
Forge is not a framework for writing agents. It is the runtime that takes a complete agent config — defined in AgentHub against the TeamSpec specification — and executes it. Forge handles the mechanics: spawning, tool dispatch, failure recovery, human-approval gates, and audit logging. You define what the agent should do. Forge handles making it happen.
Agent logic, permissions, and behavior are defined in AgentHub configs. Forge reads those configs and executes them. This separation means the same agent definition can run in dev, staging, or production — with Forge enforcing environment-appropriate constraints each time.
Forge was designed alongside the TeamSpec specification. Every dimension the spec requires — authority management, failure handling, observability — has a corresponding Forge mechanism. You are not bolting compliance on after the fact. It is built in.
Forge runs in your own infrastructure. Your agent executions, your data, your audit logs — none of it leaves your environment. The source code is available under Apache 2.0. Inspect it, audit it, extend it, or contribute back to the project.
Forge follows a consistent execution lifecycle for every agent it spawns. Each step is logged, recoverable, and auditable.
Forge fetches the agent config from AgentHub — pulling the specific version requested, or the latest production-tagged version. Config validation runs before any execution begins. If the config is malformed or references unavailable tools, Forge rejects it immediately.
Forge instantiates the agent with the resolved model, system prompt, and tool set from the config. Tool access is scoped to exactly what the config declares — no broader permissions are available at runtime, regardless of what the LLM requests.
The agent runs against its assigned task. Tool calls are dispatched by Forge, which intercepts each call to enforce permission boundaries, apply rate limits, and log the action before and after execution. The agent never calls tools directly.
When an agent attempts an action above its autonomous authority threshold — sending an external communication, modifying production data, spending budget — Forge pauses execution, surfaces the approval request to the configured human reviewer, and resumes only on explicit approval.
When a tool call fails, Forge applies the configured retry policy: exponential backoff, fallback tool selection, or human escalation. Failed sub-tasks are queued, not dropped. Partial results are preserved. The agent can resume from the last successful checkpoint.
On completion, Forge writes the full execution record to AgentHub: every tool call, every decision point, every approval event, every retry, and the final outcome. The audit trail is immutable and queryable. Compliance questions get answers, not approximations.
Forge and AgentHub are designed as a pair. AgentHub is the authoritative source of agent configs. Forge is the runtime that executes them. Together they form the complete TeamSpec operations layer.
Forge never stores its own agent definitions. Every spawn starts by fetching the specified version from AgentHub. This guarantees that what executes is exactly what was reviewed, approved, and version-tagged — not a local copy that might have drifted.
After each run, Forge records the execution event in AgentHub's audit log — which config version ran, who triggered it, what happened, and the outcome. AgentHub becomes the record of both configuration history and execution history in one place.
Forge exposes a plugin interface for custom tool integrations. If your stack has internal APIs, databases, or services that agents need to call, you register them as Forge plugins with defined permission scopes. They behave identically to native tools from the agent's perspective.
Forge is open source and runs entirely within your environment. Your agent executions, your data, and your audit logs never leave your infrastructure.
Clone the Forge repository. Forge runs as a service alongside your existing infrastructure. Docker Compose, Kubernetes manifests, and a Helm chart are all included in the repository.
github.com/teamspec/forge →Point Forge at your AgentHub instance with an API key that has execute permissions. Forge will discover all agent configs you have access to and make them available for spawning immediately.
Learn about AgentHub →Register the external services your agents will use as Forge tool plugins. Set permission scopes for each tool. Forge will enforce those scopes at runtime — agents cannot call tools or scopes you have not explicitly registered.
Trigger a Forge spawn via the REST API, the CLI, or a webhook. Select the AgentHub config and version, supply the task description, and Forge handles the rest. Check the execution trace in AgentHub when it completes.
TeamSpec is open source. FastBytes.io offers implementation consulting — from initial Forge deployment through production hardening, tool plugin development, pipeline design, and team onboarding. If you need it done right and done fast, talk to FastBytes.