Agentic Schematics GitHub ↗

THE AGENTIC SCHEMATIC SPEC

Publish a schematic.
Anyone builds it. No coordination.

A schematic is a self-contained build specification — every requirement, parameter, dependency, phase, and acceptance test for a capability — published once, implementable by any LLM, team, or org, in any runtime, without ever contacting the author. The spec is the only coordination mechanism.

Browse Schematics View on GitHub
0schematics
10binding principles
0coordination required

What is an Agentic Schematic?

In Daniel Suarez's Daemon, the Darknet spreads through shared schematics: publish the spec, and independent teams build the network — no central authority, no coordination, no permission. An agentic schematic applies the same pattern to software capabilities: the author publishes once, and any builder anywhere can construct the capability from the spec alone.

The schematic replaces the author. No meetings, no shared history, no access to the original conversation. If a fact matters, it lives in the package — or it doesn't exist.

📦

Self-contained

Every requirement, parameter, dependency, phase, and test lives inside the package. No "see the original repo", no "ask the author".

🔌

Vendor-agnostic

Plain Markdown and portable shell. No agent tool names, no harness features, no skill formats. Any LLM with a shell and a text editor can execute it.

♻️

Idempotent

Every implementation phase is safe to re-run. Verification gives the same verdict every time. The spec never depends on "do it like last time".

🧩

Modular

Every separable concern is a module with an explicit contract: inputs, outputs, dependencies, failure behavior. No hidden coupling.

🎛️

Parameterized

Every environment-specific value is a named parameter with a discovery method. Behavior differences between deployments are configuration, never code edits.

🧹

Pluggable

Clean seams with a stated removal procedure. Detach the capability and the host keeps working.

How it works

1

Author or reverse-engineer

Write a schematic from an idea, or distill one from a working implementation. Install the schematics plugin and its create-schematic skill walks any agent through it.

2

Publish once

One Markdown file is the entire coordination. Push it to a repo, paste it into a session, hand it to a stranger — the package carries everything.

3

Anyone builds, independently

Any LLM in any runtime follows the phases, discovers local parameters, and proves the result against the acceptance tests. The author is never consulted.

SCHEMATIC.md (skeleton) 
---
name: my-schematic
version: 0.1.0
status: draft
description: One-line summary copied to the marketplace
---

# Schematic: <Capability>

## Applicable Context
- **Must discover locally:** <commands>
- **May assume:** <with risk>
- **Must not change:** <host constraints>

## Requirements       → R-1, R-2, ... (testable)
## Dependencies       → D-1, D-2, ... (with failure behavior)
## Parameters         → P-1, P-2, ... (with discovery methods)
## Modules            → one contract per module
## Implementation     → idempotent phases with verification
## Acceptance         → A-1, A-2, ... (one per requirement)
## Removal            → stated, safe uninstall procedure

The Catalog

Every entry is an installable plugin, and every plugin carries a schematic — the build specification for its capability. Capability plugins ship a SCHEMATIC.md you can copy and implement anywhere, no plugin required. Live from .agent-schematics/marketplace.json.

The Spec

The ten binding principles

  1. Vendor-agnostic — no agent-specific tools or formats
  2. Portable — no absolute paths or machine-specific literals
  3. Self-contained — the package is the complete world
  4. Predictable — identical layout, sections in the same order
  5. Idempotent — re-runnable without damage
  6. Parameterized — every tunable in one table
  7. Dependencies called out — with discovery and failure behavior
  8. Applicable context stated — discover vs assume vs don't-change
  9. Configuration flexibility — behavior is config, never code edits
  10. Pluggable — clean seams and a stated removal procedure

File formats, self-describing

Uncommon file types ship with their own .schema companion that documents the format, so an agent with zero prior knowledge of the syntax can still work with it:

  • agent.rego + agent.rego.schema — Rego policy language guide
  • openssl-server.conf + .conf.schema — OpenSSL config syntax
  • SCHEMATIC.md + SCHEMATIC.md.schema — this spec's own format
  • marketplace.json + marketplace.json.schema — catalog format

The convention: every <name>.<ext> gets a <name>.<ext>.schema alongside it.