Forge

Forge is the tool that turns a set of curated sources into an expert pack. It lives inside the Node — same application, same port — and is reachable from the Forge button at the bottom of the sidebar. There is no separate Forge install, no CLI variant, no alternative entry point. Building a pack and using a pack happen on the same Node.

This page covers what Forge does, the inputs it accepts, the modes it operates in, and what gets produced. The full anatomy of a pack — frontmatter, page structure, conventions — lives in Anatomy of a pack.

What Forge does

You give Forge a set of sources you trust. Forge synthesizes them into a structured pack:

• It extracts the concepts present in the sources.
• It writes a dense factual page for each concept, drawing only from what you provided.
• It cross-links related concepts with curated wikilinks.
• It maintains an index and a log that make the pack searchable and auditable.
• It keeps the original source documents immutable in a raw/ folder, so any reader can trace any fact back to its origin.

The same workflow produces both kinds of pack:

• Private packs stay on your machine. Personal notes, internal company documents, research data. The Node uses the pack to answer your questions; the content never leaves your computer.
• Public packs are submitted to the OCC registry for community review. Approved packs are deployed to the broker and become available to every Node in the network.

The choice is just where the pack lives at the end. The build process is identical.

The Forge panel

The panel is split in two: a form on the left, a live terminal output on the right (drag the divider to resize). The form is organized into the following sections.

Pack

• Name — the pack identifier: lowercase letters, digits, and hyphens. Auto-completion lists existing packs on disk. The pack will live at expert-packs/<name>/ and is identified by that name everywhere.
• Extraction model — the cheap, fast model that reads each source and identifies which concepts to extract. Default: GPT-5 Mini. Options: GPT-5 Mini, GPT-5, Claude Sonnet 4.6.
• Writing model — the quality-critical model that writes the wiki pages. Default: GPT-5 Mini (fine for most topics). Switch to GPT-5 only for dense technical or code-heavy material where the cost is justified.

Sources

Three kinds of input, in any combination:

• Files — drag and drop or click to attach .txt, .md, or .pdf files. Multiple files allowed.
• URLs — one per line. Forge fetches each URL with a robust extractor (trafilatura for general pages, the Wikipedia API for Wikipedia URLs).
• Text — paste documentation, notes, or any text directly. The text is ingested as one or more raw documents.

Two optional checkboxes:

• Img — fetch images from URLs + vision fallback for PDFs. Two effects:

  1. For URL sources, Forge fetches <img> tags larger than 5 KB, captions them with the Extraction model, and embeds the relevant ones into the wiki pages.
  2. For PDF files, when a page extracts very little text (likely a scanned image or formula-heavy page), Forge rasterizes the page and sends it to the Extraction model for vision transcription. Adds vision LLM cost.

• Math — extract LaTeX/MathML from URL sources. When enabled, Forge pulls mathematical formulas (LaTeX, MathML, Wikipedia math fallback images) from URL sources and injects them as inline LaTeX in the raw text. For Wikipedia, switches to the parse API to access formulas. No vision cost — pure HTML parsing.

The four modes

Four modes determine what Forge does with the existing pack on disk:

Add sources

The default and the everyday mode. Forge extends the pack with new sources without losing what was already there. Concepts the model recognizes as duplicates of existing pages update those pages — adding new facts, flagging contradictions, raising or lowering confidence — rather than creating a second page on the same topic. The pack grows incrementally.

Resume interrupted

Continues an interrupted run. Keeps wiki pages already written, skips sources recorded as complete in wiki/log.md, processes only the remaining ones, then cross-links and finalizes. Use after a crash, a timeout, or a manual stop.

Recompile from raw

Forge wipes the wiki pages but keeps the original source documents (raw/) untouched. It then regenerates every page from those raw sources using the current prompts and conventions. Use after Forge itself has improved — better prompts, tighter conventions, cleaner cross-link logic — and you want existing packs to benefit. No network calls; only LLM cost.

Rebuild from scratch

Forge deletes everything — wiki pages, raw documents, the log, the manifest's source list — and starts fresh. It re-fetches every URL, re-reads every file, and rebuilds the entire pack from zero. Most expensive option; use rarely.

Running Forge

Click Run Forge. The terminal on the right streams progress live: fetching source 1 of 3, extracting concepts (12 found), writing pages (5/12), cross-linking… The whole run can take from a couple of minutes (a handful of short sources) to a few hours (large documents at GPT-5 quality).

A persistent run banner appears at the top of the app while Forge is running, with elapsed time, a View button, and a Stop button. You can switch tabs or open another chat without losing track of the build.

Roughly, a build proceeds in six steps:

1. Source acquisition. Files are read, URLs are fetched, pasted text is taken as-is. Each source is saved verbatim under raw/articles/ with a date-prefixed filename.
2. Concept extraction. The Extraction model reads each source and identifies the concepts present — usually one concept per topic the source addresses.
3. Page writing. For each concept, the Writing model produces a dense factual page in the pack's house style. Concepts that match an existing page trigger an enrichment call instead, merging the new material with the existing content.
4. Cross-linking. A separate pass examines each newly-written page and proposes wikilinks to the most directly related pages, validated against the pack's index.md. The result populates the page's ## See Also section.
5. Index update. The pack's index.md is regenerated from the actual frontmatter of every page on disk — titles, summaries — so the search-relevant metadata always matches what the pages say.
6. Log entry. An entry is appended to wiki/log.md with timestamp, source name, and number of pages written.

Lint — quality control

Below the main Forge controls is the Lint section. Lint runs structural and semantic checks on a finished pack and can be invoked at any time, independently of a build run.

Structural checks

Check	What it verifies
C1 Structure	Required files exist; frontmatter parses.
C2 Frontmatter	Required fields present and valid on every page.
C3 Index consistency	Every row in index.md matches a file on disk, and vice versa.
C4 Link integrity	Every wikilink resolves; ## See Also sections are bidirectional.
C4b Source provenance	Every concept page traces back to a file in raw/.
C5 Tag hygiene	Near-duplicate tags are collapsed.
C11 Canonical placement	Each file is in the correct directory.

Semantic audit

When an LLM model is selected for Lint, an additional pass runs over the pack content checking for:

• Safety — disallowed content, hate speech, or material that violates the OCC content rules.
• Topic coherence — pages stay within the pack's stated scope.
• Contradictions — two pages making incompatible claims on the same fact.

Auto-fix

The Auto-fix repairable issues checkbox enables structural fixes:

• Regenerate index.md from disk.
• Normalize frontmatter (fill missing fields with sensible defaults).
• Strip invisible Unicode characters.
• An LLM-powered fix for missing manifest summaries.

Items that cannot be safely auto-fixed (real contradictions, missing sources, ambiguous tags) are reported as warnings for the author to address.

Models

Forge separates model choice from the Node's runtime. The Node always answers through Qwen — that is the network's contract. Forge, by contrast, is a one-shot synthesis tool whose output is static markdown that any Node can later read.

After the build

A built pack lives at expert-packs/<pack-name>/ on the user's machine. It is a normal directory of markdown files. From here, three paths:

• Use it locally. Toggle the pack on in Settings → Knowledge Source and it is immediately available for queries.
• Submit to the community. Follow Submitting a pack to push it to a public GitHub repository and open a review on the OCC registry.
• Deploy privately. For private packs inside an organization, deploy to a self-hosted broker and make the pack available only to participating Nodes.

The deploy mechanics — for community submission and for self-hosted brokers — are described in Governance and the operator documentation.

---

The structural details of a pack on disk (frontmatter fields, conventions, See Also format, source tracking) are covered next, in Anatomy of a pack.