A high-integrity micro-learning platform for Active Inference and the Free Energy Principle: a validated prerequisite graph whose every quantitative claim is produced by a tested kernel, exported to SkillTree. DOI: 10.5281/zenodo.21865644
Repo ActiveInferenceInstitute/Active_Skillference, read from GitHub 13 h ago. ActiveInferenceInstitute has not joined Take My Repo.
ActiveInferenceInstitute/Active_Skillference is a public repo on GitHub by ActiveInferenceInstitute. A high-integrity micro-learning platform for Active Inference and the Free Energy Principle: a validated prerequisite graph whose every quantitative claim is produced by a tested kernel, exported to SkillTree. DOI: 10.5281/zenodo.21865644. It declares the MIT license on GitHub. It is written mainly in Python, has 2 stars and last changed on 2026-11-18. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
A high-integrity micro-learning platform for Active Inference and the Free Energy Principle, built on the NSA-origin open-source SkillTree framework.
Active Skillference renders the Active Inference / FEP body of knowledge as a validated
prerequisite graph spanning all eight strata, from the mathematics of surprise through
to applications, where every quantitative claim a learner sees is produced by a tested
computational kernel, never hand-typed. The validated graph exports directly into
SkillTree's Project → Subject → Skill data model with prerequisite learning-paths and
quiz-gated completion, and can seed a live, gamified instance over REST. The manuscript
also validates scholarly support through a source-role matrix before generated artifacts
are emitted.
docs/README.md (index) · docs/quickstart.md · docs/architecture.md · docs/learner_dashboard.mdgit clone https://github.com/ActiveInferenceInstitute/Active_Skillference.git
cd Active_Skillference
./run.sh # dependencies, build, live SkillTree, learner dashboard
./run.sh --offline # no Docker: build and serve generated artifacts only
./run.sh --check # report readiness and exit without starting anything
One command from a fresh clone to a browser page you can learn from. Each step says what it is doing and what to do if it stops; a run that refuses with a reason is working as intended. The live path needs a running Docker daemon because SkillTree owns quizzes, completion, points, and ranking. The offline path needs neither Docker nor a network.
Help, readiness, and artifact-only exits do not initialize passwords. Live launchers share the password owner; bootstrap may skip seeding only with --skip-seed-if-live-content-ready after semantic content verification, not matching counts. Offline artifacts and controlled regressions do not prove a live official SkillTree display.
Generated outputs are committed, so the artifacts are browsable straight from the repository:
| What | Where |
|---|---|
| The archived manuscript, exactly as deposited | Active_Skillference_v1.0.0_DOI-10.5281-zenodo.21865644.pdf |
| The current build of the manuscript | output/pdf/Active_Skillference_combined.pdf |
| Every generated figure | output/figures/ with figure_registry.json |
| The SkillTree export | output/data/skilltree_project.json |
| The claim ledger | output/data/claims.json |
| Audits and coverage records | output/data/ |
| Web, DOCX, EPUB and slide builds | output/web/, output/docx/, output/epub/, output/slides/ |
| Dashboard screenshots | manuscript/assets/screenshots/ |
Committing them does not weaken the regenerability claim. Running the kernels rebuilds
every one from source, and validate_rendered_freshness.py fails if a committed artifact
has drifted from what the current source produces. Only renderer logs and LaTeX
intermediates are withheld, since they change on every run and carry nothing to read.
The two PDFs are deliberately distinct. The root file is the frozen v1.0.0 deposit,
byte-identical to what 10.5281/zenodo.21865644 archives (MD5 7e43004d…), so the
filename's claim about that DOI stays true no matter how the source moves on. The file
under output/pdf/ is the current build from the current source, and will differ whenever
the manuscript has changed since the deposit.
Versions. The repository is at v1.0.1; the Zenodo deposit archives the v1.0.0 manuscript. The DOI is unchanged and still correct to cite, because v1.0.1 adds committed outputs, a rewritten README, and the code-availability wording, and revises no result. A future release that changes the science gets its own version DOI under the same concept.
SkillTree itself is developed in the National Security Agency open-source ecosystem (press release, skills-service, code.nsa.gov). Active Skillference cites that provenance for platform context only; it is not an NSA endorsement and does not replace deployment threat modeling, supply-chain attestation, or organization-specific access-control review.
{{claim:NAME}}
tokens that resolve to tested-kernel outputs. The export fails closed if any token is
unbacked, and a linter rejects bare result numbers typed into prose.manuscript/references.bib and data/scholarship_sources.yaml, where each source has
a support lane, role, kind, and locator.data/course_material_sources.yaml, which pins external Active Inference Institute
course and knowledge-base repositories by commit instead of copying prose or using
unpinned embeddings.LICENSE and metadata
files, records vendored/runtime notices in THIRD_PARTY_NOTICES.md, and keeps the
owner-confirmed public-review boundary explicit in
docs/ip_license_status.md.src/ coverage gate.mathematics → probability → information theory → variational methods → the Free Energy Principle → active inference → computation → applications
The discrete active-inference agent kernel (src/kernels/active_inference.py, the
sample/commit model of src/kernels/examples.py) is specified in
gnn/discrete_active_inference_agent.gnn.md in
Generalized Notation Notation
(GNN): the informative sensor, the sample/commit transition tensor, the neutral
preference vector, and the uniform state prior.
The gate parses the specification with the extractor pinned in
gnn/upstream.json and checks that the declared matrices reproduce
the kernel's expected-free-energy values. It reads the parser source with git archive
at the recorded commit.
Merges to main require gnn conformance (local). The hosted
gnn conformance (pinned) job remains optional.
Use a clean checkout of the current PR head. Prepare the frozen Skillference environment
with uv sync --frozen and stage the parser before starting the offline run. Use a
dedicated checkout containing the recorded commit and its tag, plus a Python 3.12
environment with numpy and defusedxml for the parser. From the Skillference checkout,
set GNN_ROOT to a new scratch path and run the preparation commands below. In GitVault,
follow its repository admission rules for this staging work.
set -eu
repo=ActiveInferenceInstitute/Active_Skillference
: "${PR_NUMBER:?Set PR_NUMBER}" "${GNN_ROOT:?Set GNN_ROOT to a new absolute scratch path}"
pr_head=$(gh pr view "$PR_NUMBER" --repo "$repo" --json headRefOid --jq .headRefOid)
test "$(git rev-parse HEAD </dev/null)" = "$pr_head"
changes=$(git status --porcelain </dev/null)
test -z "$changes"
gnn_revision=$(jq -er .commit gnn/upstream.json)
gnn_tag=$(jq -er .tag gnn/upstream.json)
gnn_repo=$(jq -er .repository gnn/upstream.json)
test "$gnn_repo" = ActiveInferenceInstitute/Generalized_Notation_Notation
mkdir "$GNN_ROOT"
git init --quiet "$GNN_ROOT" </dev/null
git -C "$GNN_ROOT" remote add origin "https://github.com/$gnn_repo.git" </dev/null
git -C "$GNN_ROOT" fetch --depth 1 origin "$gnn_revision" \
"refs/tags/$gnn_tag:refs/tags/$gnn_tag" </dev/null
git -C "$GNN_ROOT" checkout --quiet --detach "$gnn_revision" </dev/null
test "$(git -C "$GNN_ROOT" rev-parse --verify "refs/tags/$gnn_tag^{commit}" </dev/null)" = "$gnn_revision"
uv venv --python 3.12 --no-project "$GNN_ROOT/.venv"
GNN_PYTHON="$GNN_ROOT/.venv/bin/python"
uv pip install --python "$GNN_PYTHON" numpy defusedxml
For a standalone run from the Skillference checkout, export GNN_ROOT and
GNN_PYTHON, then run the same ./gates.sh gnn arm with the prepared environments.
set -eu
export GNN_ROOT GNN_PYTHON
uv sync --frozen --check --offline
UV_OFFLINE=true UV_FROZEN=true UV_NO_SYNC=true ./gates.sh gnn
For GitVault publication, run both checks in its governed offline test runner
(execute --classification test, described in GitVault's docs/EXECUTE.md). Bind
the intent to the clean PR head and pin inputs. Pass both absolute parser paths as
arguments to the test runner and set GNN_ROOT and GNN_PYTHON inside the child so
the launcher cannot drop them. Set VAULT_ROOT to the configured GitVault checkout
and GNN_INTENT to the prepared test intent. From the PR checkout, run the gate
with its existing project Python.
"$VAULT_ROOT/_tools/vault" execute \
--classification test --intent "$GNN_INTENT" --repository "$repo" --cwd "$PWD" -- \
"$PWD/.venv/bin/python" -B -c '
import os, subprocess, sys
from pathlib import Path
out = Path(os.environ["GITVAULT_EXECUTION_OUTPUT"])
env = dict(os.environ, GNN_ROOT=sys.argv[1], GNN_PYTHON=sys.argv[2],
TMPDIR=str(out), TEMP=str(out), TMP=str(out), PYTHONDONTWRITEBYTECODE="1",
GIT_NO_REPLACE_OBJECTS="1", UV_PROJECT_ENVIRONMENT=str(Path(sys.executable).parent.parent))
def run(argv, log):
with (out / log).open("x") as stream:
subprocess.run(argv, env=env, stdin=subprocess.DEVNULL, stdout=stream,
stderr=subprocess.STDOUT, check=True)
run(["uv", "sync", "--frozen", "--check", "--offline"], "locked-environment.log")
run([sys.executable, "-B", "scripts/validate_gnn_spec.py"], "conformance.json")
run([sys.executable, "-B", "-m", "pytest", "tests/test_gnn_conformance.py",
"-q", "-p", "no:cacheprovider"], "pytest.log")
summary = (out / "pytest.log").read_text().splitlines()[-1]
if "passed" not in summary or "skipped" in summary or "failed" in summary:
raise SystemExit("Pinned GNN tests must pass with zero skips")
' "$GNN_ROOT" "$GNN_PYTHON" </dev/null
Keep the strict validator JSON, pytest log and terminal receipt. The validator must succeed, and the focused pytest suite must finish with zero skips or failures.
An authorized maintainer uses the configured GitVault launcher with the
mapped Institute identity and the state write class enabled. Set VAULT
to that launcher's absolute path, PR_NUMBER to the pull request number, and
GNN_EXIT_RECEIPT to the governed run's exit.json. Review the passing
gate output and its nonempty, zero-skip test report before planning success.
set -eu
repo=ActiveInferenceInstitute/Active_Skillference
context='gnn conformance (local)'
: "${VAULT:?Set VAULT}" "${PR_NUMBER:?Set PR_NUMBER}" "${GNN_EXIT_RECEIPT:?Set GNN_EXIT_RECEIPT}"
tested_head=$(jq -er --arg repo "$repo" '
.payload | select(.classification == "test" and .outcome == "SUCCEEDED"
and .returncode == 0 and .source_unchanged == true and .binding.source == $repo
and .descendants.sample_errors == 0 and .descendants.remaining == [])
| .binding.revision | select(test("^[0-9a-f]{40}$"))
' "$GNN_EXIT_RECEIPT")
test "$(gh pr view "$PR_NUMBER" --repo "$repo" --json headRefOid --jq .headRefOid </dev/null)" = "$tested_head"
digest=$(shasum -a 256 "$GNN_EXIT_RECEIPT")
status_parameters=$(jq -nc --arg repo "$repo" --arg head "$tested_head" --arg context "$context" \
--arg digest "${digest%% *}" '{
repository:$repo, expected_commit:$head, context:$context, state:"success",
description:("Local pinned GNN checks passed. Receipt SHA-256 " + $digest[:16])
}')
plan=$("$VAULT" plan github-status --parameters "$status_parameters" </dev/null)
plan_id=$(printf '%s\n' "$plan" | jq -er .github)
confirmation=$(printf '%s\n' "$plan" | jq -er .confirmation)
"$VAULT" github-apply --plan "$plan_id" </dev/null
Review the repository, commit, context, and exact confirmation phrase in the plan. In the same shell, recheck the live PR head before applying. Confirm that GitHub reports the local context as a passing required check. A new head needs a fresh run and publication.
test "$(gh pr view "$PR_NUMBER" --repo "$repo" --json headRefOid --jq .headRefOid </dev/null)" = "$tested_head"
"$VAULT" github-apply --plan "$plan_id" --apply --confirm "$confirmation" </dev/null
gh api "repos/$repo/commits/$tested_head/status" </dev/null |
jq -e --arg head "$tested_head" --arg context "$context" '
.sha == $head and any(.statuses[]; .context == $context and .state == "success")'
test "$(gh pr view "$PR_NUMBER" --repo "$repo" --json headRefOid --jq .headRefOid </dev/null)" = "$tested_head"
gh pr checks "$PR_NUMBER" --repo "$repo" --required --json name,bucket </dev/null |
jq -e --arg context "$context" 'any(.[]; .name == $context and .bucket == "pass")'
For specification edits, start from GNN's Start Here, framework integration guide, and syntax reference. For the wider picture (the adoption patterns sibling repositories use, pin discipline, and the drift guard these checks implement), see GNN's downstream adoption guide at the v5.1.0 pin.
gnn/ directory.Each concept has one canonical home: this repository owns the discrete agent kernel and its curriculum; the other two specify their own models.
| Path | Contents |
|---|---|
src/kernels/ |
Tested computational kernels (the source of every claim) |
src/provenance/ |
Claim registry + provenance binding/lint gate |
src/scholarship/ |
Citation source-role coverage validation |
src/manuscript/ |
Figure registry / manuscript / dashboard artifact drift validation |
src/curriculum/ |
Typed model, prerequisite-DAG engine, and the Active Inference catalog |
src/skilltree/ |
Curriculum → SkillTree exporter, REST clients, local auth bridge, and seeder |
src/figures/ |
Deterministic, data-driven figures |
src/dashboard/ |
Local learner dashboard shell over generated artifacts + official SkillTree views |
src/pilot/ |
Protocol-only learner-pilot contract and privacy/missing-data validation |
src/screenshots/ |
Captured browser evidence: manifest, capture driver, build-time staging |
src/publication/ |
Zenodo DOI reservation and the separate, confirmation-gated publish path |
scripts/ |
Thin orchestrators (build / run kernels / export / seed / capture / validate) |
manuscript/ |
The platform write-up, its assets, and the captured dashboard screenshots |
output/ |
Committed generated artifacts: figures, data, audits, PDF, web, DOCX, EPUB, slides |
data/ |
Authored inputs: scholarship matrix, claim-support rows, course-material pins |
gnn/ |
The GNN specification of the discrete agent kernel and the pinned GNN revision |
docs/ |
Documentation, grouped by the question you arrived with (index) |
vendor/ |
Runnable SkillTree instance wiring (see vendor/README.md) |
run.sh |
Cold start to the learner surface, with offline and readiness modes |
gates.sh |
The single gate entry point: every offline arm CI runs (docs/gates.md) |
uv sync
uv run python scripts/build_curriculum.py # DAG stats + diagnostic gap map
uv run python scripts/analyze_scholarship.py # citation coverage + source-health network
uv run python scripts/run_kernels.py # claims, scholarship, figures, companions, audits
uv run python scripts/build_course_materials.py # local Learn material records
uv run python scripts/validate_claim_support.py # validate manuscript scientific support
uv run python scripts/export_skilltree.py # provenance-gated SkillTree JSON
uv run python scripts/validate_course_material_alignment.py # material/quiz parity
uv run pytest --cov=src --cov-fail-under=90 # full suite, ≥90% coverage
./scripts/run_skilltree.sh # docker compose up (skills-service + Postgres) + seed
# then open http://localhost:8080
The pinned local stack uses SkillTree password auth (FORM). The service starts and
/public/status is reachable without credentials; run_skilltree.sh then uses the
local bootstrap path to create/reuse local admin state, seed the project, and verify the
trusted-client token exchange. Direct admin seeding through scripts/seed_skilltree.py
still requires deployment-supported admin auth such as SKILLTREE_TOKEN.
See vendor/README.md for the Docker and build-from-source paths.
./scripts/run_learning_dashboard.sh
# then open http://127.0.0.1:8765
The dashboard serves a no-build HTML/CSS/JS interface from this project. The Official
Display tab embeds SkillTree's own skills-client-js learner view, so the page CSP
names the SkillTree origin in both frame-src and (as ws:///wss://) connect-src;
the browser console gate fails closed if either is missing. First paint does not wait on
the live dependency-parity read — the page loads /api/status?defer_live=1, then swaps in
checked parity — and large JSON responses are gzip-encoded on request. In the default
local path it bootstraps one local SkillTree root/admin account, stores local-only secrets
under ignored .active_skillference_local/, seeds activeInference, and exposes
/api/skilltree/token as a server-side trusted-client bridge for the official
skills-client-js learner display. Browser JavaScript never receives the admin password,
client secret, or bearer token. Learner identity is the fixed local id local-learner;
the dashboard's Learn buttons open local modular material records, while progress,
ranking, quiz completion, and self-reporting remain SkillTree-owned. Artifact-only mode
still shows generated curriculum diagnostics, scholarship-health buckets, figure
companion tables, and exact offline/local-auth/missing-material states without claiming
live learner progress.
Raw SkillTree at http://localhost:8080 remains the real SkillTree FORM login surface.
For a fresh local Docker volume, the development root login is:
username: active-skillference-admin@localhost.invalid
password: active-skillference-local
Override these fresh-bootstrap defaults with
ACTIVE_SKILLFERENCE_LOCAL_ADMIN_USERNAME and
ACTIVE_SKILLFERENCE_LOCAL_ADMIN_PASSWORD. Existing
.active_skillference_local/skilltree_auth.json state remains authoritative; inspect it
with uv run python scripts/bootstrap_local_skilltree.py --show-local-credentials.
If browser login at http://localhost:8080 rejects the documented email/password, the
local Docker volume likely predates these defaults. Reset only the local SkillTree
runtime and restart both sites with:
uv run python scripts/reset_local_skilltree.py --confirm-local-reset
The reset command stops the detached dashboard if present, backs up the ignored local
auth file, runs docker compose down -v, recreates SkillTree with the deterministic
default login, and leaves the learner dashboard running at http://127.0.0.1:8765.
By default reset proves the fast app-ready path: SkillTree login, dashboard health,
token bridge, live skills/subjects, artifacts, raw FORM login, and browser proof. Full
live prerequisite parity is intentionally separate because the pinned SkillTree container
can spend a long time validating late dependency writes on Apple/ARM Docker emulation:
uv run python scripts/reconcile_live_dependencies.py --check-only
uv run python scripts/reconcile_live_dependencies.py --max-edges 5
uv run python scripts/reconcile_live_dependencies.py --max-runtime-seconds 900
uv run python scripts/reconcile_live_dependencies.py
uv run python scripts/validate_full_app_stack.py --skip-regenerate --keep-running
The reconciler treats the live SkillTree graph as authoritative and the ignored progress
file as advisory. --check-only refreshes/reports parity without writing edges; bounded
--max-edges and --max-runtime-seconds runs are useful on slow Docker/Colima hosts and
return explicit partial JSON until live dependency parity is reached.
The dashboard also shows a Local SkillTree Login card with the default credentials
and reset/show-credentials commands.
For shared or deployed SkillTree instances, replace these local defaults with deployment
auth, SKILLTREE_TOKEN, or a deployment-owned trusted-client authenticator.
See docs/learner_dashboard.md for routes, ownership
boundaries, and offline behavior.
uv run python scripts/validate_full_app_stack.py
# or keep the dashboard open after proof:
uv run python scripts/validate_full_app_stack.py --keep-running
This is the fail-closed local app proof. It requires Docker plus a running
Docker Desktop/Colima daemon, starts SkillTree with docker compose up -d, waits for
http://localhost:8080/public/status, regenerates generated artifacts, bootstraps local
SkillTree auth, seeds the current activeInference export, starts the dashboard at
http://127.0.0.1:8765, reconciles missing live prerequisite edges, checks live admin
count parity, requires live dependency parity, checks figure-registry/dashboard contract
parity, proves the raw SkillTree FORM login with chrome-devtools-axi, and runs the
browser console gate. Use --app-ready for the faster local usability proof that does
not claim full dependency parity.
If Docker is installed but the daemon is down, the validator fails with an explicit
preflight message instead of falling back to artifact-only mode.
For national-security or regulated environments, treat the dashboard and Docker stack as local development tooling unless your organization adds its own zero-trust access controls, SBOM/provenance/signing process, monitoring, incident response, and SkillTree operator controls.
Released at
github.com/ActiveInferenceInstitute/Active_Skillference,
archived on Zenodo at
10.5281/zenodo.21865644. The same DOI
appears in CITATION.cff, codemeta.json, .zenodo.json, manuscript/config.yaml, and
on the manuscript cover page; tests/test_publication_readiness.py cross-checks every one
of them against data/zenodo_reservation.json and fails on any divergence, so a wrong
identifier cannot reach a citation. Cite with CITATION.cff or the DOI.
Authored code and content are MIT licensed (LICENSE), copyright Daniel Ari Friedman.
Vendored runtime dependencies and their separate notices live in
THIRD_PARTY_NOTICES.md; the release boundary is tracked in
docs/ip_license_status.md and
docs/publication_readiness.md.
Everything under output/ is regenerable and committed for convenience. The
learner-dashboard evidence in manuscript/assets/screenshots/ is different in kind: a
recording of a running system is not a function of project data and cannot be rebuilt from
a checkout at all, so those images live beside a provenance record naming the dashboard
address, viewport, live SkillTree counts, full-stack proof mode, capture timestamp, and a
digest per image. They are registered in figure_registry.json as
evidence_kind: captured, held to the same caption, alt-text, and chart-contract floors as
the generated figures, and excluded from the deterministic render/registry parity check
because no generator emits them. No gate can detect a screenshot that has gone stale
against a changed interface, so re-capture after any change to what the dashboard displays:
uv run python scripts/capture_dashboard_screenshots.py
One entry point runs every offline gate: ./gates.sh (default: lint, types, fast) and
./gates.sh all for the full set, with ./gates.sh gnn for the pinned conformance check and
./gates.sh render for the manuscript PDF. CI runs the same arms, so a command here is the
command CI runs; docs/gates.md documents each arm and
docs/gate_metrics.md carries the measured per-arm wall times.
Full test suite · ≥90% src/ line coverage gate · ruff + mypy clean · no mock frameworks ·
every {{claim}} resolves · provenance linter clean. Re-running the kernels regenerates
every number and figure in the curriculum; exact current coverage comes from the test
report.
The gates that run offline are enforced in CI. The live proofs are not: Docker, a seeded
SkillTree, raw FORM login, and the browser console check need a daemon and a real
browser, so they stay local and are deliberately never simulated. A green badge here means
the offline gate set passed, and nothing more. Full live dependency parity has been proven
locally against skills-service 4.6.0.
Two boundaries stated plainly. SkillTree's NSA-origin provenance is cited for platform
context and is not an endorsement of this curriculum. This release makes no claim of
learner efficacy: the learner-pilot contract in src/pilot/ is protocol-only, defining
privacy, exports, and missing-data handling without storing learner state or measuring
outcomes.
Issues and pull requests are welcome at
the repository.
Before changing curriculum content, kernels, or the manuscript, read
AGENTS.md for the invariants and docs/ for the layer
you are touching. The short version: numbers reach learners only through claim tokens, the
prerequisite graph stays acyclic and connected, citations resolve in two places, and every
gate fails closed. Run ./gates.sh all (or the individual arms — lint, types,
artifacts, checks, test, docs, gnn, render) before opening a pull request;
docs/gates.md lists exactly what each arm runs.
This repository carries a committed .aii/ sidecar with curated
InstituteOS metadata (aii-sidecar/v1): category, maturity, ecosystem relations,
key artifacts, provenance, and portable tasks. It is read by
InstituteOS tooling and
does not affect the project's build or runtime.
ActiveInferenceInstitute/Active_Skillference is a public repo on GitHub by ActiveInferenceInstitute. A high-integrity micro-learning platform for Active Inference and the Free Energy Principle: a validated prerequisite graph whose every quantitative claim is produced by a tested kernel, exported to SkillTree. DOI: 10.5281/zenodo.21865644.
It declares the MIT license on GitHub.
Its maker tagged it for macOS, Windows and Linux, or as Docker or cross-platform. That is declared by the maker; Take My Repo has not tested it.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-18. GitHub counts 0 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
freeCodeCamp.org's open-source codebase and curriculum. Learn math, programming, and computer science for free.

Deep active inference agents using Monte-Carlo methods

🎓 Path to a free self-taught education in Computer Science!
Transcripts, metadata, captions, and translations from the Active Inference Institute's video library — a structured, source-namespaced dataset generated by Journal-Utilities.
Unofficial repo for materials and code related to "Fundamentals of Active Inference" (Namjoshi 2026).

Methods for specifying, checking, typing, rendering, executing, analyzing, and visualizing state space models, for Active Inference and Beyond.
Multi-language Active Inference framework combining ant-colony-optimization-inspired multi-agent simulation with variational message passing, implemented across 50 programming languages for research and benchmarking.
CPU-oriented Python library for discrete Active Inference experiments in radCAD and cadCAD: deterministic grid worlds, multi-agent transitions, generative-model helpers, and fail-closed validation.
Knowledge base and Python package for discrete and continuous Active Inference: generative models, expected free energy, POMDP simulation, and an executable manuscript with reproducible validation commands.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/ActiveInferenceInstitute/Active_SkillferenceTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.