AgenticSystemCore

SummaryAn open format and a set of rules that turn a folder of Markdown into a wiki, a graph, an agent memory, a skills library, starting architectures and a shared live board for agents and people, published here as a node of itself.

Auto-wiki, distributed agentic memory, live specifications, evolving skills, starting architectures and a self-driving live board — one open format for people and agents. Reference Node Level-0 of the Agentic Knowledge Web.

AgenticSystemCore turns one folder of Markdown into a website, a knowledge graph and a local tool server for AI assistants at once — every link typed, every published artefact carrying a digest a reader can check, every change merged by a person or by a rule that person recorded — so people, search engines and AI agents read the same checked knowledge, with no server, database or language model needed to build, check or publish it.

The graph of this node, drawn in your browser from its published graph.jsonld. Hover a node for a second to read its summary. Open the explorer to search, list and inspect every node, to add the peer node it names, or to explore another node.

AgenticSystemCore is an open specification and reference implementation for knowledge that people and software agents can both read, verify and build on: a memory substrate that is deterministic, auditable, and governed by published conformance rules rather than by convention.

This site publishes the specification and is itself a node of it: its vocabulary items, its discovery document, its graph and its agent-facing text file follow the rules they describe, and the discovery validator checks the site at Level 2 before every publish.

What each reader gets

You areYou getWhere
A person with notesa wiki that checks and links itself, and a project's living memorythe Mode 0 guide: agsc init, a security contact, one commit, agsc ci, agsc build
A teama live board and shared skillsthe six modes, skill packs, this site's own board
An agent or an assistantmemory it can find, verify and cite; tools on every item pagethe discovery document, llms.txt, the chunk export
An implementera specification with vectors and standalone checkers, in any languagethe specification, how to read it
A publisherstatic files, no server to run and nothing to pay for beyond hostingpublish a Level-0 node

What is different about it

Other systems have some of these. To the author's knowledge none has them together: a knowledge base a machine can find through registered web mechanisms, a digest on every artefact its discovery document links, a typed graph with a published vocabulary, bytes pinned by conformance vectors, a person on every merge — directly, or by a standing rule that person recorded — and a starting harness out of the same files, with no server.

These are claims about the specification's text and its test vectors, not performance claims. The dated comparison with other systems is in the related work, and the full sentence in the introduction.

How it compares

What it shares with others' work, and how it differs:

Details in the paper; source on GitHub.

Six ways to use it

One folder of files, one format, six ways of using it. The six modes explain each.

What it is best for

For agents

For people

Works with the tools you already use

Every name below is read from the reference engine's own registries when this page is built.

A distributed brain, with no server

Each node is a folder of files published as a static site. Nodes find and read each other through registered web mechanisms, every file they point at carries its digest, and they share one vocabulary. A node names its peers; a reader walks from one to the next. No node calls another, and no server sits in between. This node's peer is a second node, patterns.agenticsystemcore.com: a demonstration node run by the same reference engine, whose sample content is a small set of well-known agent-system patterns described from public sources.

what the build emits pages for people graph: JSON-LD, RDF llms.txt, chunks discovery document Markdown items + one config file deterministic build one folder in, every surface out — the same bytes on every machine
The highlighted discovery document is where an agent starts; people start at the pages. Both come from the same files.

Measured, reproducible

Measured against specification 1.0.0 with the reference engine; each command reproduces its line, run in a clone of the engine repository at the release tag, with <dir> a folder outside the clone. In the token and accessibility lines, <scratch>/node_modules holds the packages those layers load from outside the clone (gpt-tokenizer; playwright-core and axe-core), <chrome> is a Chrome or Chromium executable, --nodes takes each node's name and built site, and --exports each node's llm-context export. None of these is a comparison with another system.

WhatResultReproduce with
Conformance243 vectors pass, 0 fail, of 250 (7 withdrawn); 327 of 332 active rules have a machine checkSOURCE_DATE_EPOCH=1767225600 node bench/measure.js --layer conformance --scratch <dir>
Determinism49 files compared across two builds, and across time zones and locales: 0 differSOURCE_DATE_EPOCH=1767225600 node bench/measure.js --layer determinism --scratch <dir>
Security floor108/108 seeded faults handled, 14/14 clean controls left alone. This proves neither safety nor the absence of new kinds of injection (AGSC-08-19)SOURCE_DATE_EPOCH=1767225600 node bench/measure.js --layer security --scratch <dir>
Accessibility0 automated violations on the 100 pages this site had when it was measured, in the light and dark schemes; automated checks find only part of what matters, so this is a floor, not a claimSOURCE_DATE_EPOCH=1767225600 NODE_PATH=<scratch>/node_modules CHROME_EXE=<chrome> node bench/measure.js --layer a11y --scratch <dir> --nodes <name>=<www>,…
Build scale5,000 items built in 34.6 s, 10,000 in 86.6 s (median of three runs, one machine); 0 pages over the 100 KB budgetSOURCE_DATE_EPOCH=1767225600 node bench/measure.js --layer perf --scratch <dir> # sizes 100 500 1000 5000 10000, 3 runs each, median
Tokens per chunkmedian 100 tokens per chunk of this site's chunk export (cl100k_base)SOURCE_DATE_EPOCH=1767225600 NODE_PATH=<scratch>/node_modules node bench/measure.js --layer tokens --scratch <dir> --nodes <name>=<www>,… --exports <name>=<dir>,…

Get started

Install the command line (Node.js 22.13 or later, git), then, in a folder of Markdown notes:

npm install --global agentic-system-core   # puts agsc on the PATH
agsc init     # each note gets a type, a title and its provenance
mkdir -p .well-known && printf 'Contact: mailto:you@example.org\n' > .well-known/security.txt
git init -q && git add -A && git commit -q -m 'my notes'   # the build takes its instant from this commit
agsc ci       # lint, build twice, compare the bytes, verify
agsc build    # the site, the graph and the agent files in www/
agsc mcp      # give an assistant seven tools over the same folder

Without the security contact, agsc ci stops with AGSC-E901; without a commit (or SOURCE_DATE_EPOCH), with AGSC-E204. The Mode 0 guide walks through it with the lines each command prints, and the guides do the same for every mode. The demos run each mode from an empty folder; the assistant setup guide and the start page for each kind of reader go further.

This site is a node of itself

Everything published here follows the rules it publishes: the vocabulary items, the discovery document, the graph and the agent-facing text file are written by the reference engine, and the discovery validator checks this site at Level 2 before every publish. The status page says which further parts are live.

Where to start

Propose an edit — opens content/index.md; a submitted change becomes a pull request a person reviews.