SYSMLv2 · MARKDOWN · YAML APACHE-2.0 DOC-SML-001 ● ACTIVE DEVELOPMENT
Models that
engineers
actually read.

Syscribe is a plain-text modeling format that maps SysMLv2 semantics onto Markdown files with YAML frontmatter. Version-controlled, diff-friendly, LLM-readable — with a built-in validation engine, traceability queries, an MCP server for LLM agents, and a web browser.

Read the format spec Start modeling Practitioner guide git clone github.com/sjames/syscribe
01 FORMAT BASIS
Markdown + YAML frontmatter
Each element is a .md file; directory path encodes namespace; body is documentation
02 SEMANTICS
SysMLv2-aligned
PartDef, PortDef, InterfaceDef, Requirement, TestCase, ADR, Allocation, FeatureDef, safety & security analysis, PlanningItem, Diagram — 70+ element types (syscribe spec types)
03 TRACEABILITY
§12 — enforced traceability rules
OSLC link direction · breakdown ADR · leaf assignment · domain classification · HW/SW independence · deployment allocation · implementation trace · suspect links · release baselines
04 VALIDATION
400+ error & warning codes
Cross-reference resolution, coverage, safety/security consistency, feature-model SAT analysis, multi-repo drift — full catalogue in syscribe spec validation
05 WEB BROWSER
Axum + Askama + HTMX
Server-rendered tree browser, element detail, BDD/IBD/StateMachine/Mermaid diagrams, validated in-browser editing — or a static site via export-html
06 TOOLCHAIN
Rust · prebuilt binaries · zero config
One CLI for validation and queries, an MCP server for LLM agents, an LSP server for editors, and a GitHub Action for CI: syscribe -m model/ validate
Systems models that live in your repository.

Traditional MBSE tools keep models in proprietary binary formats: opaque to diff, hostile to code review, and invisible to the LLMs that increasingly assist engineering work. Syscribe puts the model in plain text where it belongs — readable in any editor, diffable in any VCS, and parseable by any tool.

The format enforces SysMLv2 semantics through YAML frontmatter schema validation and cross-reference resolution, so you get modeling rigour without a heavyweight IDE. Requirements carry stable REQ-* IDs that survive renames. TestCases carry TC-* IDs traceable back to requirements. ADRs carry ADR-* IDs that justify every decomposition decision.

Because every element is a separate file, it has a stable URL in any git host. A GitHub permalink to Requirements/Safety/REQ-ENG-SAFE-001.md points to that exact requirement at that exact commit — forever. JIRA tickets, Confluence pages, code review comments, and CI reports can all link directly to a specific requirement, test case, or architecture decision, pinned to a branch tip, release tag, or commit hash.

Element types
70+
Validation codes
400+
Diagram kinds
BDD · IBD · SM
Demo models
4 bundled
Backend
Rust
Config required
Zero
model_auto/Requirements/Safety/REQ-ENG-SAFE-001.md yaml · Requirement
1---
2type: Requirement
3id: REQ-ENG-SAFE-001
4name: Safety monitor shall detect all
5  safety faults within 100 ms
6status: approved
7reqDomain: software
8asilLevel: D
9verificationMethod: test
10derivedFrom:
11  - REQ-ENG-SAFE-000
12breakdownAdr: ADR-ENG-SAFE-001
13derivedFromSafetyGoal: SG-ENG-001
14---
15 
16The safety monitor software component
17**shall** detect any single-point safety
18fault within 100 ms of fault onset.

Stable REQ-* IDs survive moves between packages. Derivation, the breakdown ADR, safety-goal linkage and domain are checked across the whole model by the validation engine.

Everything a systems model needs.
STRUCT
Structural hierarchy
PartDef, ItemDef, PortDef, InterfaceDef, ConnectionDef — full SysMLv2 structural decomposition in plain files.
REQ
Native requirements
Stable REQ-* IDs, lifecycle status, SIL/ASIL fields, normative text, derivation trees, domain classification.
TC
Test cases
TC-* IDs, L1–L5 test levels, Gherkin scenarios, testFunctions cross-reference, active/retired lifecycle.
ADR
Architecture decisions
ADR-* IDs with proposed/accepted/deprecated/superseded status. Every requirement decomposition cites an accepted ADR.
DIAG
Multiple diagram kinds
BDD, IBD, StateMachine, Requirement diagrams via structured frontmatter. Mermaid diagrams via fenced code blocks.
OP
Interface operations
Synchronous operations and async receptions on PortDef and InterfaceDef — typed parameters, return types, isQuery flag.
ALLOC
Allocations
Function-to-component and requirement-to-component allocation with cross-reference validation and domain checks.
PLE
Product-line engineering
FeatureDef/Configuration elements with appliesWhen conditioning, SAT-backed feature analysis, and per-variant validation — variant modeling without a separate tool.
LIVE
Live browser
Axum server with file-system watcher. HTMX partial updates — tree navigation, element detail, and editable diagrams without a page reload.
SAFE
Safety & security analysis
HARA, safety goals, fault trees, FMEA, TARA and cybersecurity goals as model elements — integrity levels checked against the requirements they drive.
TRACE
Traceability that survives change
Suspect links flag a reviewed trace whose target has since changed; release baselines freeze a git-anchored, content-hashed snapshot and detect drift.
LLM
Built for LLM agents
An embedded authoring prompt, an MCP server with guarded writes (dry-run, validation delta, commit gate), and native PlanningItem work tracking with claim/release for multi-agent work.
INGEST
Bring other sources in
Native SysMLv2 textual submodels, foreign formats via stdio plugins, and model elements declared in source-code comments — all merged into one validated graph.
REPO
Multi-repository composition
Import peer repositories, resolve references by stable ID, gate on git ref drift, and consolidate lower-tier product lines through sub-configurations.
LINK
User-defined link types
Declare project relationships in .syscribe.toml with source/target types, cardinality and acyclicity — validated and walkable with follow.
Up and running in four steps.
STEP 01 — INSTALL
Get the toolchain

Prebuilt syscribe binaries are on the GitHub releases page. To build from source (needed for the web server), use Rust stable.

# clone the repo git clone github.com/sjames/syscribe cd syscribe # build the CLI and the web server cargo build --workspace
STEP 02 — VALIDATE
Run the validator

Point it at any of the bundled demo models. The full report covers element inventory, requirements traceability, and all findings.

# Engine ECU (ISO 26262 / 21434) syscribe -m model_auto/ # SIL 4 railway interlocking syscribe -m model_sil/ # findings only syscribe -m model_auto/ validate
CLI reference
STEP 03 — BROWSE
Open the web browser

The server watches for file-system changes and reloads automatically. Browse the tree, read rendered documentation, and edit diagrams in place.

# start the server syscribe-server -m model_auto/ # open in browser http://localhost:3000/
Browser docs
STEP 04 — QUERY
Explore with queries

Trace a requirement end-to-end, find what a component satisfies, or get the next available ID before adding a new element.

# full trace for a requirement syscribe -m model_auto/ \ trace REQ-ENG-SAFE-001 # what does this component satisfy? syscribe -m model_auto/ \ why System::Software::SafetyMonitor # next available ID syscribe -m model_auto/ \ next-id REQ-ENG-SAFE
Engine ECU demo
Compared to existing modeling approaches.
SYSCRIBE
CAPELLA
PAPYRUS
CAMEO
Model format
Plain Markdown + YAML
Proprietary XMI
UML2/XMI
Proprietary
VCS-friendly diff
Yes — line-level
Binary / XML
XML (partial)
Binary
LLM-readable
Yes — native text
No
No
No
Validation engine
Built-in (Rust, CI-able)
GUI warnings
OCL constraints
Built-in
Web browser
Included
No
No
No
Cost
Open source
Free (Eclipse)
Free (Eclipse)
Commercial
SysMLv2 alignment
Semantic subset
SysML 1.x
SysML 1.x
SysML 1.x / 2
Feature comparison based on public documentation, 2026-05. Syscribe is a semantic subset of SysMLv2 — not a full implementation.
Why I built this.

I started using LLMs for development as soon as they were usable. The speed was unlike anything I'd seen — hard problems that would have taken weeks collapsed into days. But I came from automotive engineering, and I couldn't stop asking the uncomfortable questions: who reviewed this decision? what requirement does this satisfy? how do I know it's correct?

The automotive world has spent decades building processes — HARA, FMEA, traceability matrices, change notices — that exist because overconfident engineering kills people. An LLM that generates requirements with no formal check is just a faster way to produce undetectable mistakes. The obvious fix — slow the LLM down with process overhead — defeats the point.

Syscribe is my answer to that tension. Plain text so the LLM can write it. A validator so it can't silently be wrong. Git so every decision has an author, a date, and a diff. The speed of LLM-assisted authoring with the rigour that automotive engineering actually requires — not as a compromise, but as a design choice.