AI / Agent Infrastructure · Independent R&D
System Control Plane
A software-engineering system in development for structuring, building, auditing and improving projects through AI agents and deterministic control.
α
Origin and context
System Control Plane started as a working methodology to reduce cost, token consumption and redundant work while developing BlockFactory.
What began as a way to organize the workflow gradually accumulated contracts, state, evidence, memory, tools and verification mechanisms until it became a system in its own right.
Today SCP is a software-engineering platform in development that structures how agents, tools and deterministic components participate in building and evolving real projects.
β
Engineering method
SCP combines Spec-Driven Development with PDCA and Lean principles and evolves software through small, specified and verifiable deltas.
Before execution, the objective is defined, requirements and work are structured, the change is built, the result is audited and the resulting evidence feeds the next cycle.
ENGINEER coordinates the overall process; PLAN reasons and structures work without execution; CONTROL deterministically materializes context, contracts and work units; BUILD performs the change; AUDITOR verifies the outcome against the specification and evidence.
- Objective
- Requirements
- Tasks and work sets
- Refinement
- Build
- Audit
- Evidence and improvement
γ
Hybrid architecture
SCP does not delegate the entire engineering process to a generative model. It combines specialized agents with deterministic components.
Agents are used where interpretation, planning, implementation or review is valuable, while workflow control, contracts, persistence, policies and parts of validation remain outside the model.
- Multi-agent systems
- Structured contracts
- Memory and RAG
- DAGs and dependencies
- MCP and tools
- Persistence and recovery
- Model and tool routing
- Evidence, provenance and history
- Observability and token/cost measurement
δ
Existing projects and self-hosting
SCP includes an ingestion module for existing projects, building the context required to operate on codebases that were not originally created by the system.
From that context, it can apply the same cycle of understanding, specification, construction and auditing.
SCP also applies that process to its own codebase: its evolution follows the same engineering cycle it provides to other projects.
This does not mean unrestricted autonomous self-modification; it means that SCP itself is one of the real environments in which its engineering process is used and evaluated.
ε
Strategy engine
I designed a strategy engine that represents strategies, context and outcomes within a dynamic vector space.
Structures such as GoalGraph, Strategy Graph/Fabric and ExecutionGraph separate objectives, strategy and execution while preserving the relationships between them.
The system can retrieve related prior experiences, inspect which strategies were used and evaluate how they performed under different conditions.
Decision Records and Strategy Experience preserve decisions and outcomes so future executions can reuse previous evidence rather than depending exclusively on immediate context.
New execution results feed the space again, allowing the system to progressively study the relationship between context, strategy, execution and outcome.
ζ
Efficiency and bounded decisions
Reasoning cost was one of the original problems behind SCP and remains an explicit design dimension.
The architecture favors deterministic or local processing when generative reasoning is unnecessary and reserves more expensive models for decisions where they add value.
Internal policies and tooling measure model usage, context, token consumption and cost. TokScale instruments consumption while routing mechanisms such as ModelRouter select resources according to the work.
Models and components can be evaluated by quality, stability and cost to determine which combination is appropriate for a given type of task.
JEV is currently being evaluated as an experimental layer for bounded, structured decisions that do not require open-ended generative responses.
η
Current state and technologies
SCP is an active project in development. Operational infrastructure already exists for executing a significant part of the cycle, working with projects, persisting information, using agents and tools and producing evidence.
The implemented foundation includes a persistent runtime, durable state and decisions, deterministic verification and auditing, execution evidence, and recovery and continuity across runs.
Some capabilities continue to evolve, while others remain experimental or research directions.
The central question behind the project is how to build software with AI agents while preserving specifications, control, evidence, memory and the ability to improve.
Technologies and concepts: Python, agents, LangGraph, RAG, DAGs, MCP, Docker, Git, CLI, contracts, SQLite, persistence, observability, evidence/provenance, model routing, semantic retrieval, Spec-Driven Development, PDCA and Lean.