Forge — An Open, Secure, Portable AI Agent Runtime for the Enterprise

Forge is the open-source runtime for Anthropic's Agent Skills standard — built for the agent that runs next to a service, in your environment, on infrastructure you already operate. Write a SKILL.md. Compile to a portable, hardened agent. Deploy it anywhere containers run: Kubernetes, on-prem, air-gapped, embedded in CI, or as an A2A endpoint.

Why Forge?

60-second setup — forge init wizard configures provider, keys, channels, and skills
Secure by default — outbound-only connections, egress allowlists, encrypted secrets, no public listeners
Portable — same agent runs locally, in Docker, Kubernetes, or inside Initializ Command
Observable — structured NDJSON audit logs with correlation IDs for every action
Extensible — add skills, tools, channels, and LLM providers without changing core code

Quick Start

# Install (pick one)
brew install initializ/tap/forge
curl -sSL https://raw.githubusercontent.com/initializ/forge/main/install.sh | bash

# Create and run an agent
forge init my-agent && cd my-agent && forge run

# Connect to Slack
forge run --with slack

See Quick Start for the full walkthrough, or Installation for all methods.

How It Works

SKILL.md --> Parse --> Discover tools/requirements --> Compile AgentSpec
                                                            |
                                                            v
                                                    Apply security policy
                                                            |
                                                            v
                                                    Run LLM agent loop
                                               (tool calling + memory + cron)

You write a SKILL.md. Forge compiles it into a secure, runnable agent with egress controls, encrypted secrets, and audit logging.

Key Features

Feature	Description
Atomic Skills	`SKILL.md`-based agent definitions with YAML frontmatter
Egress Security	Runtime + build-time domain allowlists with subprocess proxy
Channel Connectors	Slack (Socket Mode), Telegram (polling) — outbound-only
Cron Scheduling	Recurring tasks with channel delivery
Memory	Session persistence + long-term vector search
LLM Fallbacks	Multi-provider with automatic failover
MCP Client	Connect to any HTTP MCP server (Linear, Notion, Atlassian, ...) — tools surface as `<server>__<tool>` with namespaced audit
Web Dashboard	`forge ui` for browser-based agent management
Build Signing	Ed25519 artifact signing & verification
Air-Gap Ready	Runs with local models, no cloud required

Documentation

Getting Started

Document	Description
Quick Start	Get an agent running in 60 seconds
Installation	Homebrew, binary, and Windows install
Architecture	System design, module layout, and data flows

Core Concepts

Document	Description
Skills	Skill definitions, registry, and compilation
Binary Dependencies	How `forge build` resolves, installs, and places skill-declared binaries
Tools	Built-in tools, adapters, and custom tools
Runtime	LLM providers, fallback chains, running modes
Memory	Session persistence and long-term memory
Context Compression	Reversible compression of bulky tool outputs — fewer tokens, nothing lost
Channels	Slack and Telegram adapter setup
Scheduling	Cron configuration and schedule tools
Tracing	OpenTelemetry distributed tracing — spans, propagation, audit cross-link

Security

Document	Description
Security Overview	Complete security architecture
Authentication	Pluggable auth providers — OIDC, AWS Sigv4, GCP IAP, Azure AD
Egress Security	Egress enforcement deep dive
Secrets	Encrypted secret management
Build Signing	Ed25519 signing and verification
Guardrails	Content filtering and PII detection
Workflow Correlation	Orchestrator correlation IDs threaded through audit events
Platform Policy	Workspace-level deploy-time bounds on egress / tools / models

Operations

Document	Description
A2A Agent Card	Spec-conformant Agent Card at `/.well-known/agent-card.json` (A2A 0.3.0)
Commands	Full CLI reference
Configuration	`forge.yaml` schema and environment variables
Dashboard	Web UI features and architecture
Deployment	Container packaging, Kubernetes, air-gap
Scheduler — Kubernetes	Hybrid file/CronJob scheduler backend, RBAC, token plumbing
Hooks	Agent loop hook system
Library Modules	Import `forge-core`, `forge-skills`, `forge-plugins` as Go libraries — tag scheme, release pipeline, embedder API
Plugins	Framework plugin system
Command Integration	Initializ Command platform guide

For Claude / LLM-assisted contributors

File	Description
Forge knowledge skill	Single comprehensive markdown — drop it into a Claude conversation for full Forge context (architecture, security, APIs, CLI, audit pipeline, how to build agents + skills).
Forge skill-builder skill	Same prompt the `forge ui` Skill Builder uses. Author a valid `SKILL.md` (frontmatter + body + optional scripts) in any Claude chat — no `forge ui` needed.

/sync-docs keeps both skills current — see .claude/commands/sync-docs.md.

Philosophy

Running agents that do real work requires atomicity (explicit skills, defined tools, declared dependencies), security (restricted egress, encrypted secrets, audit trails), and portability (runs locally, in containers, in Kubernetes, in cloud — same agent, anywhere).

Real agent systems require atomicity, security, and portability. Forge provides those building blocks.

Contributing

We welcome contributions! See CONTRIBUTING.md for development setup, how to add skills/tools/channels, and the PR process.

Please read our Code of Conduct before participating.

License

See LICENSE for details.

Forge: Open Agent Skills Runtime

README