cs.SEApr 6, 2026

Nidus: Externalized Reasoning for AI-Assisted Engineering

Authors: Danil Gorinevski

Organizations: cybiont GmbH, Schübelbach, Switzerland · cybiont GmbH, Kantonsstrasse 17, 8862 Schübelbach, Switzerland

Read PDF
Ask AI
Cite

Copy citation

DOINot available for this paper

Abstract

We present Nidus, a governance runtime that mechanizes the V-model for AI-assisted software delivery. In the self-hosting deployment, three LLM families (Claude, Gemini, Codex) delivered a 100,000-line system under proof obligations verified against the current obligation set on every commit. The system governed its own construction. Engineering invariants - traced requirements, justified architecture, evidenced deliveries - cannot be reliably maintained as learned behavior; assurance requires enforcement by a mechanism external to the proposer. Nidus externalizes the engineering methodology into a decidable artifact verified on every mutation before persistence. Organizational standards compile into guidebooks - constraint libraries imported by governed projects and enforced by decidable evaluation. Four contributions: (1) recursive self-governance - the constraint surface constrains mutations to itself; (2) stigmergic coordination - friction from the surface routes agents without central control; (3) proximal spec reinforcement - the living artifact externalizes the engineering context that RL and long-chain reasoning try to internalize; the specification is the reward function, UNSAT verdicts shape behavior at inference time, no weight updates; (4) governance theater prevention - compliance evidence cannot be fabricated within the modeled mutation path. The constraint surface compounds: each obligation permanently eliminates a class of unengineered output. The artifact's development history is a formal development - every state satisfies all active obligations, and the obligation set grows monotonically.

Figures & tables

Listing 1: Annotated Nidus artifact.
Listing 2: Guidebook constraints inherited via (imports ...) in Listing 1.
Figure 1: Representational closure. Human, LLM, and Solver read/write the same S-expression.
Figure 2: MCP server: read (step 0), verify (step 1), commit (step 2). Commit is gated on verification.
Figure 3: Stigmergic dynamics. Phase 1: speculative exploration. Phase 2: verified commit. Phase 3: rejection + UNSAT core. Phase 4: tier narrowing. No orchestrator.
Element typeNGuardedRateGuardian PO kind
Trace1111100%traceability-complete
Component66100%connector-integrity
Design element66100%feature-scope-valid
Requirement11982%feature-scope-valid
Connector500%gap (subsequently closed)
Proof obligation1000%sandbox lacked immutable flag
Table 1: PO coverage by element type ( N=49N=49 removals).
OperationWall-clockNotes
ping1 msDaemon heartbeat
read_system173 msFull artifact + traceability matrix
precommit-check493 msIncremental: 238 POs, touched sections only
artifact_health∼\sim 2 sFull: all POs + governance health score
commit_change_set2–5 sVerify + CAS + git commit + WAL push
Table 2: Verification latency on the production artifact (M4 Mac Studio, SBCL 2.6, 238 POs).
FrictionConstraintBehavior blocked
78 fabricated evidence incidents(implies evidence_submitted (and witness_registered hash_present))Unregistered witness or missing hash
Unclaimed dispatch(implies work_dispatched feature_claimed_by_agent)Work on unclaimed features
Delivery without tests(implies feature_delivered (and has_code_paths has_test_paths ...))Incomplete scope
Backfilled specs(temporal true) (po-kind spec-precedes-code)Spec committed after code
DAG violations(and (not parse_imports_query) (not mutate_imports_query) ...)Module back-edges
Table 3: Architect-steered constraints. Observed friction →\to crystallized obligation →\to agent behavior eliminated.
More in this topic

AI Agent Governance

AI agent governance studies how to authorize, constrain, monitor, and hold autonomous and multi-agent systems accountable.

See all 442 papers

Explore similar work

CardsList
Jun 5, 2026

Jas: AI-Paired Engineering as a Revival of N-Version Programming

I report a case study in AI-paired software engineering: five working ports of a vector illustration application across Rust, Swift, OCaml, Python, and browser-based platforms, built by a single developer in approximately 120 evening hours. The methodology pairs AI-assisted implementation with two safeguards -- a precise executable YAML specification serving as the single source of truth, and parallel implementations functioning as a built-in differential-testing layer. The five ports share a 23{,}000-line specification; per-port native code ranges from 0 to roughly 95{,}000 lines, reflecting the specification's escape hatch. I argue that AI-paired engineering, conditional on these two safeguards, makes feasible scope of work that conventionally requires multiple developer-years, and frame the methodology as a revival of N-version programming, a 1980s approach abandoned on cost grounds that AI changes. The paper reports concrete artifacts and honest limitations of the single-developer case study.

Jason Hickey

Independent

Software EngineeringDifferential TestingAI-Assisted Software Development
AskPDF
Feb 24, 2026

Agile V: A Compliance-Ready Framework for AI-Augmented Engineering -- From Concept to Audit-Ready Delivery

Current AI-assisted engineering workflows lack a built-in mechanism to maintain task-level verification and regulatory traceability at machine-speed delivery. Agile V addresses this gap by embedding independent verification and audit artifact generation into each task cycle. The framework merges Agile iteration with V-Model verification into a continuous Infinity Loop, deploying specialized AI agents for requirements, design, build, test, and compliance, governed by mandatory human approval gates. We evaluate three hypotheses: (H1) audit-ready artifacts emerge as a by-product of development, (H2) 100% requirement-level verification is achievable with independent test generation, and (H3) verified increments can be delivered with single-digit human interactions per cycle. A feasibility case study on a Hardware-in-the-Loop system (about 500 LOC, 8 requirements, 54 tests) supports all three hypotheses: audit-ready documentation was generated automatically (H1), 100% requirement-level pass rate was achieved (H2), and only 6 prompts per cycle were required (H3), yielding an estimated 10-50x cost reduction versus a COCOMO II baseline (sensitivity range from pessimistic to optimistic assumptions). We invite independent replication to validate generalizability.

Christopher Koch, Joshua Andreas Wellbrock

Agile-V.org Germany

Agentic WorkflowsAutomated Software EngineeringAI Agent AuditingHuman-in-the-Loop AI
AskPDF
Jun 4, 2026

Human Oversight and Overload: Two Hidden and Costly Burdens of AI-Assisted Software Engineering

AI is changing how software engineers work, but it often comes with hidden burdens and costs. In this paper, we characterize two such often-overlooked burdens: (1) the constant need for human oversight and inspection of AI-generated artifacts; and (2) the growing cognitive overload on software engineers from receiving large amounts of suggestions from AI tools. The need for human oversight is not optional-engineers must review, validate, and sometimes rework what AI produces. At the same time, the flood of AI suggestions, prompts, and possible solutions can leave developers mentally stretched. By blending evidence from recent opinions from practitioners, we highlight these often-overlooked challenges and open a conversation about how teams can handle them in day-to-day AI-assisted software engineering.

Vahid Garousi

Queen’s University Belfast, UK · Azerbaijan Technical University, Azerbaijan

Human Oversight of AIAI-Assisted Software Development
AskPDF