Skip to content

Autonomous AI Development Lifecycle & Sentinels (Antigravity & Google Jules)

Document Metadata
🗓️ Last Modified: 2026-09-29
👤 Author / Owner: @JakubDedik & Antigravity
🏷️ Status: Active Standard
🔗 Linked System Components: GitHub Actions CI/CD, Jules Autonomous Coder, Coveroq.Cad.Orchestrator, Self-Hosted Runner (pc-jakub)

This document details the automated, closed-loop AI software engineering pipeline and autonomous sentinel framework powering the COVEROQ CAD Platform. It explains how human architectural intent is transformed into production-ready software without manual boilerplate coding or continuous oversight.

🏛️ The Paradigm: Architecture as the Guardrail

In traditional software development, architecture is often treated as a set of recommendations or documentation diagrams. In our AI Co-Development model, architecture is the active execution constraint:

  1. Deterministic Guardrails: Models are guided by compiler rules (.NET 10 TreatWarningsAsErrors), custom Roslyn Analyzers (CCAD001–CCAD015), contract tests (Coveroq.Cad.ArchitectureTests), strict layer dependencies, and isolated execution scopes.
  2. Probability Management: Rather than manually micro-managing every line of AI code, human engineers define strict boundaries (APIs, DTOs, interfaces) and automated gates (CI, linter, tests).
  3. Zero Blast Radius: Rule 10 ensures CAD tools and geometry calculators remain strictly self-contained CLI applications (solid_3d.py, inspect_model.py, drawing_2d.py), preventing local experiments from degrading global web services.
  4. Zero-Fallback Rule (Rule 12): System workflows have exactly ONE deterministic execution path. Silent retries or client-side fallback mocks are forbidden. Failures emit immediate telemetry context (TraceId, CorrelationId).

🔄 The Closed-Loop Multi-Agent Workflow

sequenceDiagram
    autonumber
    actor Architect as Lead Architect (Human)
    participant IDE as Antigravity IDE
    participant ALM as GitHub Project 1 (ALM)
    participant Dispatcher as Coveroq.Cad.Orchestrator Watchdog
    participant Jules as Google Jules (Coder Agent)
    participant Runner as pc-jakub Runner (CI)
    participant Sentinel as Sentinels (Drift / Hygiene / Coverage)

    Architect->>IDE: Defines Feature / Scope Intent
    IDE->>ALM: Generates Task with Strict Criteria via Orchestrator create-task
    ALM->>Dispatcher: Issue labeled 'jules-queued'
    Dispatcher->>Jules: Dispatches Task via Google Jules REST API
    Note over Jules: Reads Parent Story & AGENTS.md Rules
    Jules->>Jules: Writes C# Code + Unit / Integration Tests
    Jules->>ALM: Opens Pull Request (PR)
    ALM->>Runner: Triggers CI Verification on pc-jakub
    Runner->>Runner: Compiles .NET 10, Runs Roslyn Analyzers & Vitest
    Runner->>Dispatcher: Evaluates PR diff via review-pr
    alt Violations Detected
        Dispatcher->>Jules: Sends structured feedback into active session
        Jules->>Jules: Fixes violations & pushes new commit
    else All Rules Passed
        Dispatcher->>ALM: Approves & Auto-merges PR
        ALM->>Dispatcher: PR Closed Event
        Dispatcher->>Jules: Automatically dispatches NEXT task in queue!
    end
    Note over Sentinel: Sentinels audit repo & queue refactoring tasks automatically

🛡️ Autonomous Sentinels Framework (Coveroq.Cad.Orchestrator)

To prevent architectural erosion, codebase bloat, and telemetry dead spots over time, the Coveroq.Cad.Orchestrator runs automated sentinel audits on schedule:

1. Architecture Drift Sentinel (audit-drift)

  • Workflow: .github/workflows/architecture-drift-sentinel.yml
  • Function: Audits all C#, Python, and TypeScript modules for header pragmas (@arch-generation: v1 vs v2).
  • Action: Identifies legacy @arch-generation: v1 modules and automatically dispatches refactoring tasks to @jules via jules-queued issues.

2. Daily Codebase Hygiene Sentinel (audit-hygiene)

  • Workflow: .github/workflows/codebase-hygiene-sentinel.yml
  • Function: Audits for:
  • Orphaned / unreferenced files in cad/scripts/ or webapp/src/.
  • Discrepancies in infrastructure files (Dockerfile, docker-compose.yml, Taskfile.yml).
  • Stale @arch-generation: v1 modules untouched > 60 days or deprecated modules (@completeness: Deprecated).
  • Action: Generates aggregated GitHub Issues and queues cleanup tasks for Jules.

3. Hourly Telemetry Coverage Sentinel (audit-coverage)

  • Workflow: .github/workflows/telemetry-coverage-sentinel.yml
  • Function: Audits trace coverage across ASP.NET Core Minimal API endpoints, CQRS command handlers, and TypeScript page orchestrators.
  • Action: If trace coverage falls below 85%, it automatically creates a targeted task in the jules-queued backlog with the exact list of untraced endpoints/functions.

4. Hourly Telemetry Log Sentinel (audit-logs)

  • Workflow: .github/workflows/telemetry-log-sentinel.yml
  • Function: Downloads structured logs from GET /api/logs?limit=500, isolates HTTP 500 exceptions, worker heartbeat timeouts, and subprocess crashes.
  • Action: Deduplicates against open issues and dispatches bug fix tasks directly to Jules.

🧩 Key System Components

1. ALM Standardization & Task Dispatcher (Coveroq.Cad.Orchestrator & jules-queue.yml)

  • Hierarchical Traceability: Every developer task is linked under a parent User Story using native GitHub GraphQL Sub-issues (addSubIssue) via Coveroq.Cad.Orchestrator create-task.
  • Precise Context Framing: Tasks explicitly define target layers, benchmark files, acceptance criteria, and project metadata (Team: Engineering, Estimate, Size).
  • Autonomous Queue: When an issue is merged, jules-queue.yml triggers Coveroq.Cad.Orchestrator watchdog, which monitors Jules REST API sessions, unblocks failures automatically, and dispatches upcoming work.

2. Autonomous Execution Agent (Google Jules)

  • Powered by Google's state-of-the-art coding models (Gemini Flash).
  • Reads repository instructions from .jules/instructions.md and rules from .agents/AGENTS.md.
  • Produces clean C# 10 Minimal APIs, CQRS handlers, TypeScript components, and comprehensive xUnit/Vitest test suites.
  • Operates strictly within git branches, opening PRs against main.

3. Verification & CI Runner (pc-jakub)

  • Dedicated on-premise hardware station acting as the self-hosted GitHub Actions runner.
  • Runs full Docker builds, .NET 10 test suites, and Vitest in under 20 seconds.
  • Eliminates GitHub Actions cloud costs and ensures zero CI minutes consumption.

4. Continuous Deployment to Hardware (coveroq-cad-worker.service)

  • When PRs touching worker code are merged into main, .github/workflows/deploy-worker.yml automatically publishes binaries to /opt/coveroq-worker: bash dotnet publish backend-dotnet/src/Coveroq.Cad.Worker/Coveroq.Cad.Worker.csproj -c Release -o /opt/coveroq-worker sudo systemctl restart coveroq-cad-worker.service
  • Seamless service restart with less than 2 seconds of downtime.

📈 Comparison: Traditional vs. COVEROQ Autonomous Engineering

Aspect Traditional Development COVEROQ Autonomous Model
Boilerplate & Plumbing Manual coding (hours/days) Generated in 60–90 seconds
Architectural Enforcement Manual code reviews (subjective, prone to fatigue) Automated via NetArchTest, Roslyn Analyzers & Orchestrator review-pr (100% objective)
Drift & Hygiene Prevention Infrequent manual refactoring sprints Continuous daily auditing via Sentinels (Drift, Hygiene, Coverage)
Task Delivery Rhythm Days per ticket, blocked by meetings Continuous 24/7 autonomous queue processing
Human Role Line-by-line syntax writer System Architect & Domain Director