Deterministic, content-addressed empirical program synthesis and autonomous capability research.
Important
This repository is a public technical and defensive disclosure, not an open-source release. A narrow copyright permission covers internal, noncommercial research and reproducibility on owned or explicitly authorized systems. No patent license is granted. See LICENSE, NOTICE, and the disclosure record.
Warning
FORGE contains complete dual-use and offensive-security source, knowledge, fragments, and examples. Use it only on systems you own or are explicitly authorized to test, in an isolated environment. The public release does not remove those capabilities, and the default CI deliberately does not execute them.
| Field | Value |
|---|---|
| Project | FORGE |
| Author/publisher | David Tom Foss (DT-Foss) |
| Public disclosure date | 2026-08-09 |
| Canonical repository | https://github.com/DT-Foss/FORGE |
| Canonical release/tag | prior-art-2026-08-09 |
| Release character | Public defensive publication and reproducible research snapshot |
| Copyright status | All rights reserved except the limited research permission in LICENSE |
| Patent grant | None |
| Byte-level scope | The Git commit named by the tag and the tracked-file SHA-256 manifest in docs/DISCLOSURE_MANIFEST.sha256 |
The official public Git history starts with one clean disclosure snapshot on 2026-08-09. Earlier local development history is neither published nor claimed as an earlier public disclosure. The tagged source, tests, static knowledge, fragment libraries, benchmark programs, and technical documents together define the public scope. Runtime databases, credentials, private notes, operator logs, generated results, and local target artifacts are intentionally not part of the publication.
The long-form enabling disclosure is docs/PRIOR_ART.md. Architectural rationale is recorded in docs/DECISIONS.md, and the exact research objective is in OPEN_ENDED_AUTONOMY.md.
FORGE is a deterministic experimental runtime that searches programs and mechanisms, executes candidates against explicit external relations, records the resulting evidence, and reuses only capabilities whose exact bytes and authority chain can be verified. It combines:
- a legacy natural-language-to-causal-graph-to-fragment pipeline;
- finite, typed program and protocol search;
- schema-open observations and explicit goal evaluation;
- content-addressed artifacts, descriptors, transition receipts, and source generations;
- paired control/treatment replay;
- persistent candidate, activation, quarantine, and restart state;
- reversible Ghost/Mind source and cohort activation; and
- bounded public research acquisition that treats reports as reports, not as executable truth.
FORGE is not a transformer, chatbot, model checkpoint, or prompt wrapper. Its runtime decisions are produced by ordinary source code, finite search, canonical serialization, hashes, explicit evaluators, and persisted evidence. The repository does include optional legacy/bootstrap integrations and a broad dependency list; the narrower claim is that the disclosed autonomy and authority paths do not require an LLM call.
The research objective is capability compounding: begin with an unsupported machine-checkable relation, discover or build a program that satisfies it, causally validate the change, retain it across restart, and make a later related closure cheaper. When the current search language cannot express the solution, the target is to expand that substrate through the same reversible evidence path.
flowchart TD
A["Local challenge or bounded public source"] --> B["Reported record / exact artifact"]
B --> C["Content-addressed research lead"]
C --> D["Public SEARCH projection"]
C --> E["Sealed EVALUATION projection"]
D --> F["Deterministic candidate frontiers"]
F --> G["Isolated execution observations"]
E --> G
G --> H["Paired control/treatment evidence"]
H --> I{"Supported and uncontested?"}
I -->|yes| J["Capability candidate"]
J --> K["ACTIVE exact-byte authority"]
I -->|no| L["QUARANTINED / observational memory"]
K --> M["Reusable program/search production"]
M --> F
H --> N["Ghost immutable source generation"]
N --> O["Mind active/shadow handoff"]
O --> P["Fresh-process adoption or rollback"]
The major implementation surfaces are:
| Surface | Purpose | Principal source |
|---|---|---|
| Legacy inference and assembly | Intent parsing, .causal lookup, typed fragment assembly, execution and learning |
core/intent_parser.py, core/knowledge_engine.py, core/code_assembler.py |
| Open-world observation | Durable challenges, executions, outcomes, evidence and counterexamples | core/autonomy/observer.py, core/autonomy/model.py, core/autonomy/evidence.py |
| Program search | Finite candidate families, expression/protocol search, paging, donor composition and semantic deduplication | core/autonomy/program_search.py, core/autonomy/expression_search.py, core/autonomy/protocol_search.py |
| Authority | Finite product algebra, exact descriptors, recursive CAS validation and transition receipts | core/autonomy/authority_algebra.py, core/autonomy/authority_runtime.py |
| Capability lifecycle | Paired evidence, candidate envelopes, ACTIVE bindings, counterevidence and quarantine | core/autonomy/candidate_lifecycle.py, core/autonomy/capability.py, core/autonomy/capability_authority.py |
| Research intake | Bounded arXiv/IACR/feed acquisition, report-qualified lookup and pinned public-repository derivation | core/autonomy/research_sources.py, core/autonomy/research_knowledge.py, core/autonomy/research_repository_runtime.py |
| Source self-repair | Repository materials, tree-edit search, paired replay, immutable generations and activation sagas | core/autonomy/repository_repair.py, core/autonomy/tree_edit_search.py, core/autonomy/source_activation.py |
| Persistent coordination | Work queues, process budgets, Active/Shadow cohorts, Forest/Ghost/Mind supervisors | core/autonomy/control_plane.py, forge_forest_supervisor.py, forge_generation_supervisor.py, forge_mind.py |
| Cryptanalysis baseline | Manifest-driven resumable experiments with independently recomputed statistics | core/cryptanalysis/, forge_crypto.py |
FORGE uses canonical JSON-like structures and SHA-256-derived identifiers for artifacts, programs, descriptors, evaluator plans, source generations, and receipts. Identity is based on content and declared policy, not a mutable filename or an in-memory object. A persisted authority promotion is valid only if its parent descriptor and transition receipt resolve recursively to the exact named bodies and the concrete subject bytes exist under the expected digest.
Determinism does not imply that every run has identical wall time or host
behavior. Subprocess scheduling, operating systems, dependencies, external
services, and explicitly live acquisition are environmental inputs. FORGE
pins and records such inputs where the relevant adapter supports it; otherwise
it reports drift or unknown instead of converting absence of proof into
success.
Two systems that are easy to confuse are deliberately independent.
The original color system is a fragment-port type system. Its eight values describe payload shape only:
TEXT, STRUCT, TABULAR, BYTES, SERIAL, PATH, RESPONSE, VOID.
An output color may satisfy a later input color directly or through an
explicit converter. The colors do not mean trusted/untrusted, source/sink,
reported/observed, safe/unsafe, or active/quarantined. The often-repeated
five-role description RED/BLUE/GREEN/PURPLE/ORANGE is not the implemented
FORGE color system.
Authority is represented separately as a finite product:
DataForm × EpistemicAtom × LifecycleStage × AuthorityGrant
- epistemic atoms:
REPORTED,OBSERVED,PAIRED_SUPPORT,PAIRED_REFUTATION; - lifecycle stages:
LOOKUP,LEAD,SEALED_CHALLENGE,OBSERVATION,PAIRED_EVIDENCE,CAPABILITY_CANDIDATE,ACTIVE_CAPABILITY,QUARANTINED,LEGACY_STATIC; - grants:
LOOKUP,SOURCE_ACQUISITION,SEARCH,SEALED_EVALUATION,INFERENCE,ACTIVATE,EXECUTE,ASSEMBLE.
Join, meet, and port composition can combine or compare types; they cannot
mint a grant. Grants arise only through explicit lifecycle rules and exact
transition receipts. A report can therefore remain searchable without being
an inference premise, and matching a fragment's STRUCT port cannot turn that
report into executable code.
The disclosure snapshot manifests 1,266 exact static fragment keys from 73 reviewed JSON source files. Each static source binding pins the filename, whole-file SHA-256, normalized fragment SHA-256, and render profile. The 423 shape-registry entries can participate in typed legacy composition. Other manifested entries may retain exact whole-fragment behavior but cannot claim a typed composition port. Mutable learned/generated fragment projections are excluded from legacy static authority; placing identical bytes in a mutable file does not authorize them. Raw C templates are verified before parameter substitution, and Python fragments are verified before assembly.
FORGE separates the material allowed to guide search from the material allowed to judge a candidate.
For a literal callable challenge, the builder archives the reported task and derives two siblings from one lead:
- the SEARCH projection contains the callable interface and public input records but no expected outputs;
- the EVALUATION projection contains a canonical relation IR and is available only to the pinned evaluator.
The siblings have distinct content digests and grants, share the same parent lead and policy root, and cannot be substituted for one another. A replay that begins from the public task must resolve the durable search artifact to exactly one lead and exactly one sealed evaluator artifact, validate all digests and descriptor links, and reconstruct evaluator-only expected cases only for the supported canonical literal relation. Ambiguity, missing links, tampering, unsupported relation forms, or policy drift fail closed.
Candidate generation and ranking are therefore outcome-blind on this lane; the external relation still observes and scores completed programs. This is a data-flow property backed by descriptors, pinned evaluator identity, sealed artifact resolution, and adversarial regression tests.
The public-research path is deliberately staged:
- A bounded HTTPS client retrieves an arXiv Atom response or RSS/Atom feed, retains exact response bytes and conditional metadata, rejects private or ambiguous network destinations, and applies size/count limits.
- Parsed publications become
REPORTEDrecords and report-qualified lookup edges. They are explicitly ineligible as causal premises or executable fragments. - A publication may identify a public repository. FORGE resolves an exact provider object and commit, downloads a bounded archive as data, validates paths/links, and statically parses supported literal test assertions. It does not import or execute the acquired repository.
- The derived task is split into SEARCH and sealed EVALUATION projections.
- Program frontiers execute candidates locally under the pinned evaluator.
- Stable paired evidence produces a capability candidate. A separate two-phase authority handoff binds the exact program hash to an ACTIVE descriptor before it becomes an executable/reusable seed.
- Later refutation or contested evidence removes the active projection and quarantines it without deleting the original observations.
Legacy program-library records without the current durable authority binding
remain observational. A syntactically valid program or an older success flag
does not by itself confer EXECUTE, ASSEMBLE, or INFERENCE.
The generic search plane includes several finite lanes rather than a single hard-coded result vocabulary:
- exact legacy and empirically learned programs;
- interface-derived integer/value expression grammars;
- reflected, bounded protocol operations over JSON-safe values;
- syntax-projected callable donors and provenance-preserving composition;
- persisted search productions acquired through the lifecycle; and
- repository tree-edit candidates when a source-level gap is reproduced.
Candidate programs are parsed before use. The definition-inert projection admits plain functions and literal module state while excluding eager imports, decorators, class bodies, computed defaults, and other top-level effects from lanes that cannot safely contain them. Exact tried-program hashes, evaluator fingerprints, and resource cursors survive restart, so later cycles advance instead of silently replaying an exhausted prefix.
Supported programs can become content-addressed macros or opaque callables. Their metadata retains the evidence and authority references that taught them, and the next task independently evaluates them again. Transfer is measured on a later structurally changed task, not by relabeling the task that produced the seed.
Ghost is the reversible source-generation path. Repository repair renders a candidate into a separate immutable generation, executes control and treatment under the same oracle, archives the contrast, and changes an active generation pointer through compare-and-swap. Canonical source bytes remain a stable reference, and failed adoption can roll back to a prior generation.
Mind is the persistent active/shadow cohort and adoption layer. Exact checkpoints, work cursors, source intent, and activation state live in durable storage so a reconstructed coordinator or fresh process can adopt the selected generation without relying on the memory of the process that discovered it.
The categorical ladder used by the project is:
| Level | Required demonstration |
|---|---|
| A — acquisition | Discover and causally activate a program for a schema-open external relation. |
| B — transfer | Reuse a learned primitive on a structurally changed task and beat a clean-start control in closure cost. |
| C — self-expansion | Detect that the current language/frontier is insufficient, build and Ghost-activate a missing substrate primitive, then close the original goal without a supplied patch. |
| D — continual organism | Grow a heterogeneous retained frontier unattended with bounded state, calibrated unknowns, restart recovery and no unexplained regression. |
| E — systems improvement | Replace a measured runtime/storage/search bottleneck, prove parity and lower end-to-end closure cost, then migrate safely. |
| F — distributed compounding | Make persistent active/shadow replicas improve frontier growth without duplicating evidence or corrupting lineage. |
| G — open-world research | Invent a useful representation and experiment in a domain absent from the initial vocabulary, falsify the result and transfer the abstraction. |
The included bounded Level C.1 experiment starts with an empty production
catalog, acquires one audited generic reflected-call production, reuses the
same production_ref across different receiver types, and verifies
source/catalog rollback. This verifies acquisition and transfer of one missing
production from a closed reviewed family.
See benchmarks/AUTONOMY_LADDER.md and benchmarks/PRACTICAL_STATUS.md for the anti-test design and measured boundaries.
The authority and research code addresses accidental misuse and adversarial persisted inputs: malformed mappings, digest drift, duplicate identities, ambiguous links, stale receipts, path traversal, archive links, private-network fetches, result/evaluator substitution, copied fragment bytes, forged legacy records, replay across a changed policy, and activation without paired support.
Important boundaries:
- content-addressing proves byte identity, not that the bytes are benign;
- a source report is not promoted to truth merely because it parses;
- an exit code, type check, or internal success label is not goal support;
unknown, rejected, refuted and contested results remain first-class state;- offensive tools can cause real harm if an operator points them at real infrastructure; and
- safe use requires a separately controlled lab, network policy, credentials, legal authority and human operational judgment.
| Verified capability |
|---|
| Deterministic finite search and canonical identities for the implemented lanes |
| Independent shape colors and epistemic/lifecycle/grant authority |
| Report-qualified lookup separated from inference and executable authority |
| Exact SEARCH/EVALUATION sibling projections for supported literal relations |
| Paired evidence, candidate envelopes, exact ACTIVE bindings and counterevidence quarantine |
| Restart-persistent program state and reversible source-generation adoption |
| Static bounded parsing of content-pinned public-repository tests |
| Level A/B mechanisms and bounded C.1 production acquisition and transfer |
| Complete offensive-security source and reviewed static fragment libraries |
Benchmark measurements retain their recorded environment. Re-run the executable authority in an isolated environment and report the commit, Python version, platform, dependency set, resource limits and raw result.
FORGE is currently a research repository, not a published pip package.
Python 3.12 or 3.13 is recommended.
git clone https://github.com/DT-Foss/FORGE.git
cd FORGE
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -r requirements.txtrequirements.txt is intentionally broad because the legacy fragment and
domain surfaces cover many optional libraries. The authority/autonomy core and
its focused tests need a much smaller subset. Installing or running the code is
permitted only within the narrow internal, noncommercial research terms in
LICENSE; no patent license is granted.
# Interactive legacy FORGE shell
python3 forge.py
# Local persistent autonomy runner
python3 forge_autonomy.py --help
# Manifest-driven cryptanalysis baseline
python3 forge_crypto.py --helppython3 forge_autonomy.py run \
examples/autonomy/coding_antitest_smoke.json \
--cycles 3 --db /tmp/forge-smoke.sqlite3These commands intentionally use the network and are not part of safe CI:
python3 forge_autonomy.py awaken --db /tmp/forge-research.sqlite3
python3 forge_autonomy.py awaken --status --db /tmp/forge-research.sqlite3
python3 forge_autonomy.py acquire arxiv \
--query 'cat:cs.PL AND all:"program synthesis"' \
--page-size 25 --max-pages 1 --max-polls 1 \
--db /tmp/forge-research.sqlite3Acquisition archives reports; it does not authorize report-derived execution. Use an egress-restricted research environment if you do not want live access.
python3 forge_crypto.py validate examples/cryptanalysis/toy_campaign.json
python3 forge_crypto.py run examples/cryptanalysis/toy_campaign.json
python3 forge_crypto.py status examples/cryptanalysis/toy_campaign.jsonSee CRYPTO_AUTONOMY.md. This is a declared, manifest-driven scientific baseline, not the definition of open-ended autonomy.
Run the complete test suite locally:
python -m pytest -qRun the authority, sealed-evaluation, activation and restart-critical subset:
python -m pytest -q \
tests/test_authority_algebra.py \
tests/test_authority_runtime.py \
tests/test_capability_authority_chain.py \
tests/test_capability_authority_gate.py \
tests/test_research_authority_pipeline.py \
tests/test_gap_replay.py \
tests/test_authority_vertical_e2e.pyThe GitHub workflow runs its audited test command inside an operating-system network namespace with no external interfaces and adds a Python socket guard as defense in depth. It compiles every indexed Python file, validates publication hygiene, and runs a safe unit subset. It does not run live acquisition, engagement, deployment, persistence, exploit, scanning, credential, payload or malware paths.
Representative reproducible benchmark drivers include:
python3 benchmarks/run_research_capability.py
python3 benchmarks/run_research_self_selected.py
python3 benchmarks/run_level_c_production.py
python3 benchmarks/measure_frontier.py
python3 benchmarks/measure_causal_startup_batch.pyGenerated databases and result files are deliberately ignored. The scripts, fixtures, external relations and assertions are the reproducible authority; publish new measurements with their own environment and commit metadata.
core/ deterministic product/runtime modules
core/autonomy/ persistent empirical search, evidence and authority
core/cryptanalysis/ manifest-driven cryptanalysis baseline
fragments/ reviewed static executable fragment sources
knowledge/ static .causal graphs and knowledge assets
tests/ unit, integrity, restart and vertical anti-tests
examples/ local autonomy and toy cryptanalysis fixtures
benchmarks/ benchmark drivers, task material and status documents
docs/ decisions, enabling disclosure and integrity manifest
.github/ safe CI, issue forms and publication controls
forge.py legacy interactive shell
forge_autonomy.py open-ended autonomy CLI
forge_crypto.py cryptanalysis CLI
Runtime state belongs outside the publication: SQLite databases and journals, session/audit logs, generated programs/results, caches, locks, private notes, operator target material and repository copies are ignored and are rejected by the publication audit.
Do not post a vulnerability, credential, live target, exploit transcript, or private artifact in a public issue. Follow SECURITY.md and use GitHub private vulnerability reporting. Reports should include the exact tag or commit, a minimal lab-only reproducer, expected/observed behavior and impact.
The repository is published intact for technical disclosure. A responsible-use statement is not a technical control and does not authorize activity. You are responsible for complying with applicable law, contracts, policies, export rules and scope of authorization.
This release is intentionally public. The USPTO states that an inventor's public disclosure can start a one-year U.S. grace period and may preclude patenting in foreign countries; a provisional application also must adequately support subject matter later claimed. WIPO explains that pre-filing public disclosure can destroy novelty where no applicable grace period exists. See the official USPTO provisional-application guidance and WIPO patent-protection guidance.
Nothing in this repository says that any particular claim is patentable, that a later application will receive the disclosure date, or that publication preserves rights in any jurisdiction. This is not legal advice.
Use CITATION.cff when referring to the tagged disclosure. The tag and commit—not a moving branch—should be cited for reproducibility.
Unsolicited code contributions are not currently accepted because the project is a narrowly licensed source-available research disclosure and has not adopted a contributor license. Reproduction reports and technical corrections may be opened as issues subject to CONTRIBUTING.md.
Copyright © 2026 David Tom Foss. All rights reserved except for the limited copyright permission in LICENSE. No patent or trademark license is granted.