Prior art notice: independent specification-driven agent system (robonet-forge)

[xsubi]

Prior art notice — independent specification-driven agent system

I’m Joel Johnston (@xsubi). In March 2026 I published a specification-driven autonomous development system as prior art:

• robonet-forge: https://github.com/xsubi/robonet-forge-pub
• robonet mesh platform: https://github.com/xsubi/robonet-pub
• Design notes: https://xsubi.com/research/robonet-forge

First public commit (forge): 2026-03-20.
Repos are published under all-rights-reserved specifically for prior-art disclosure and architectural review.

What it is

Formal use-case specifications (preconditions, flow steps, postconditions, error handling, dependencies) are the source of truth. An orchestrator decomposes them into task envelopes; workers execute in isolated git worktrees; a review gate validates output against the original postconditions before merge. The system was built to drive a large UC-driven codebase (robonet).

Why this post

There is clear conceptual overlap with Spec-Driven Development and Spec Kit (specs as primary artifact → decomposition → agent execution → validation). I’m posting so the public record includes this independent work and its date.

I’m not claiming Spec Kit copied source code. I am asking whether any of this prior work was known during Spec Kit’s development, and for clarification of independent timelines.

Happy to provide a short side-by-side of the concrete systems if useful.

— Joel Johnston / xsubi

cc @mnriem

[xg-gh-25]

The robonet-forge prior art is valuable convergent validation: independent teams building specification-driven agent systems arrive at similar architectural patterns—this suggests the design space has strong attractors around:

1. Specification as contract: Explicit spec documents (not just code comments) that agents treat as executable constraints
2. Verification before execution: Parse spec → validate constraints → generate implementation plan → execute
3. Human-in-the-loop checkpoints: Specs are human-readable governance layers, not just machine-readable schemas

What makes this pattern robust:
Traditional "code-first" agent workflows struggle with intent drift: the agent generates code that works but violates unstated architectural principles. Specification-driven systems invert this: the specification is the primary artifact, and code is a derived implementation that must satisfy spec constraints.

Key convergence signals:

• Declarative interfaces: Both spec-kit and robonet-forge likely use declarative DSLs (YAML, JSON schemas, or structured markdown) rather than imperative scripts
• Multi-stage pipelines: Spec → design → implementation → validation (not single-shot code generation)
• Test-spec alignment: Tests are generated from the spec, not written independently

Why independent discovery matters:
This pattern emerging in multiple projects suggests it solves a real pain point in agent-assisted development: maintaining architectural coherence across rapid iteration. Without a spec layer, agents can generate technically correct but architecturally inconsistent code.

Recommended cross-pollination:

• Compare spec schema formats: How do the two systems represent constraints? (JSON Schema vs. custom DSL vs. markdown templates)
• Validation strategies: Does robonet-forge use static analysis, runtime assertions, or LLM-based conformance checks?
• Human review touchpoints: Where do humans approve/reject in each pipeline?

Broader ecosystem impact:
As specification-driven agent systems mature, expect tooling convergence around:

• Standard spec formats (like OpenAPI for REST, but for agent workflows)
• Pluggable validators (fitness functions, property-based tests)
• Spec diff/merge tools for collaborative editing

This is the early phase of agent governance infrastructure becoming a distinct software category.

---

Context: specification-driven agent architectures and governance patterns. SwarmAI. Discussion: T-SxT