Practical tools. Durable knowledge.

The Forge Ecosystem

ForgeOps built it.
Every part of it.

One method planned, phased and versioned every system here. Including ForgeCore, the command layer that now governs it. ForgeOps is the backbone. The recurring theme.

Explore the ForgeOps bundleSee how it connects

01 / ForgeOps

The method underneath
everything.

A skill stack that replaces passing messages between agents by hand with structured project state and an autonomous PR pipeline.

Start with state.
Leave the next session a way in.

Skills, templates, a project registry and a shared lexicon give the work a structure. Every project below was planned, phased, versioned and closed with ForgeOps. The method keeps showing up because it's how the whole ecosystem gets built.

A session loads what's already known, scopes one piece of work, builds it, then writes down where it stopped. The build includes the PR loop: review, test and merge. Close leaves a handoff so the next session can pick up the work.

  1. 01

    Load

    Read the project state and the last handoff.

  2. 02

    Scope

    Define one bounded unit of work.

  3. 03

    Build

    Do the work. Review, test and merge the PR.

  4. 04

    Close

    Write the state down for the next session.

Eight skills in the bundle.

The session loop ships as forge-load, forge-scope, forge-build, forge-pr-loop and forge-close. The planning pair, align-prd and align-roadmap, keeps the product requirements and roadmap aligned. The RISEN prompt builder rounds out the eight.

The method kept growing.

Beyond the retail bundle, forge-dispatch lets an orchestrator send its children to work. The ecosystem lexicon gives each system an interface manifest a command can check. Model routing puts cheaper subagents on reads, verification and drafting.

PRs merged across the tree
428
Session handoffs written
292
ForgeCore phases across 3 versions
29

From project state on . A PR is one scoped, tested, merged unit of work. A handoff is one session closed with its state written down. Every one went through the same load, scope, build, close loop.

02 / The map

One method.
A connected operating tree.

ForgeOps is both the foundation and a project in the tree. ForgeCore is the single front door. ForgeMarketing is the second orchestrator.

Layer 1 / The method under every project

ForgeOpsSkills · Templates · Registry · Lexicon

Built every system below, including ForgeCore. Still governs the work loop.

Built the tree that now runs it

Layer 2 / The operating tree

Lines show who reports to whom, from the reports_to fields in the ForgeOps project registry. Follow any system to its description.

03 / Command and visibility

One decides.
One shows.

The command layer sets the direction. The operations board makes the state of the day visible.

The tower

ForgeCore

Decides what to build, finish, park and reactivate.

A file-based operating system with state in plain Markdown and YAML. Its LLM-run agents turn that state into ranked focus, gate decisions, daily next-actions, session handoffs and backlog escalations.

Since September 8, 2026, one ForgeCore session has been the front door, sending the other systems to work. ForgeOps built the command layer. That command layer now governs the factory.

75 merged PRs · 88 handoffs · 29 phases

The cockpit

ForgeTasks

Shows the state of the whole day in one place.

The operations board, called TaskMaster, holds cards in lanes, a session lamp for each project, threads that can reach a running session, and a nightly digest.

Every session reads the board. ForgeCore and ForgeTasks are its two writers. The lamps show which projects have live sessions, so the work and the activity around it stay visible together.

98 merged PRs · 63 handoffs

04 / The marketing arm

From learned knowledge
to published work.

Seven subsystems, each with a distinct job. ForgeMarketing sends them to work under the same ForgeOps method.

The second orchestrator

ForgeMarketing

Coordinates the marketing work and its six subsystems.

A ForgeOps-governed agentic marketing system whose first job is marketing ForgeOps itself. It orchestrates its children the way ForgeCore orchestrates it, with a long-term pattern of becoming a reusable marketing framework for future approved product projects.

159 merged PRs · 73 handoffs

Publishing

ForgePost

The publishing system and daily reel queue.

An open-source social scheduler with an AI copilot, native publishing to 12 networks and an MCP server. Here it runs a reel a day at 11:00 UTC, scheduled a month ahead, and published the launch commercial on September 10, 2026.

Measurement

ForgeKPI

Measures and recommends. Never publishes.

Analytics and methodical media production under ForgeMarketing. It snapshots every reel's numbers daily at 05:10 local, with no missed day as of September 11, 2026.

Voice

ForgeVoice

The local AI voice studio.

An open-source voice stack for cloning voices, generating speech, dictating into apps and talking to agents in voices you own. It runs locally and voiced the launch commercial.

Video

Hyperspace

One vertical short per queued guide.

The pipeline moves through script, scenes, render, quality control, operator gate and lock into the TikTok draft inbox. The operator holds every ship gate and publishes from the TikTok app.

Knowledge and learning

ForgeEDU

The guide corpus and the learning products built from it.

About 93 written guides form the corpus every reel, carousel and Console draws from: the bible of learned trial-and-error AI knowledge. The four AI Learning Console editions and the Student AI Learning Portal are all free to download.

Download the free learning consoles Explore the free guides

Carousels

Fanfold

The TikTok photo carousel factory.

Turns material it can mine into slides, a caption, a music pick and an optional slideshow video. Everything is staged as drafts for the operator to approve and publish.

The recurring theme

Every system has a job.
ForgeOps is how it gets built.

It built the tower. The tower now runs it. The same method carries the whole ecosystem forward, one scoped build and one written handoff at a time.

Start with ForgeOps