System Architecture

A deterministic harness wrapping Google’s Antigravity coding-agent SDK inside an ADK 2.0 graph workflow: the agent writes 100% of the application code, and hard automated gates (pytest, static analysis) — not manual review — decide whether its output is accepted, in a closed write-test-repair loop with a hard iteration cap.

The Finding

The agent solved the task correctly on its first live attempt, but the harness’s own lint gate had a scope bug — it was linting a seed file the harness itself had planted, not just the agent’s output — and rejected a working solution five times running before the kill switch fired. Fixing the gate’s scope (not the agent’s approach) took it from always-fails to a clean first-try pass. Full write-up: PHI Anonymizer Harness Case Study.

The point isn’t the bug. It’s that a deterministic harness produces a trajectory log detailed enough to prove which layer actually failed — the agent, or its own governance.

Overview

A self-hosted control plane for running autonomous coding agents unattended, on a schedule, against real repositories — headless branch → implement → test → PR pipeline built on the Claude Agent SDK, MIT-licensed and public.

What’s actually built

• Unattended pipeline, verified end-to-end: Pointed at a real repo with a well-scoped task, the pilot branched, implemented, ran the full test suite, committed, and opened a real pull request — no manual babysitting.
• Defense-in-depth permission enforcement: A real production bug surfaced and was fixed during development — auto-approved tool allowlists were bypassing the policy callback entirely, and even after that fix, the coding agent’s own sandbox executed some commands directly without ever consulting the permission check. Closed with a pre-tool-use hook that fires before the sandboxing decision, verified against both denied and allowed commands.
• Isolated cloud deployment: Runs on a dedicated GCP project with a private VPC, deny-all ingress except IAP-tunneled SSH, NAT-only egress, and a service account scoped via conditional IAM bindings to only the two secrets it actually needs — nothing project-wide.
• File-based task queue: A pending/processing/done/failed inbox with atomic claiming, a CLI trigger surface, and a worker that runs on a timer — the first real unattended, scheduled run of the system, currently instrumented with per-run cost and success-rate metrics as the baseline for future model-routing decisions.
• Honest about scope: Still a single linear pipeline — no parallel agent fan-out, multi-profile isolation, or chat-based triggers yet.

Overview

An open-source tool that turns Regulation (EU) 2022/2554 (DORA) — a primary legal text — into a cross-referenced, navigable knowledge base rather than a flat document, extending a Higher Diploma in Business, Regulatory Risk & Compliance (DORA-focused) into a working artifact.

Build

• Authoritative-text backbone: A deterministic parser fetches the EUR-Lex HTML rendition of the regulation, parses it structurally, and asserts its output against the published article/recital/definition counts — failing the build on any mismatch rather than trusting the parse silently.
• Zero fabricated cross-references: A post-build verification pass caught and fixed an early bug where references to other legal instruments were being mislinked as internal DORA cross-references.
• Editorial layer: Hand-curated actor, concept, and obligation hub notes layered on top of the parsed text — binding specific compliance obligations to the actor and article/paragraph that impose them, without altering the verbatim source.
• Open-sourced: Published as a standalone, MIT-licensed public repository (editorial content and build tooling; the regulation’s verbatim text remains © EU under its own reuse policy), with an explicit “not legal advice” disclaimer.

System Architecture

A Morphik-style multimodal document Q&A assistant built to deliver high-fidelity information retrieval backed by verifiable source citations.

Production Implementation

• Ingestion & Retrieval: Orchestrated via LlamaIndex to process complex layout semantics across corporate documentation.
• Vector Storage: Powering low-latency semantic lookup using Qdrant vector spaces.
• Dynamic Optimization: Fully containerized backend using FastAPI to expose retrieval streams.

Live Demo Notice: The interactive RAG widget embedded below runs against a fixed, pre-ingested, and curated demo corpus. It enforces strict application-level rate limits and compute budget caps to preserve operational safety.

K9 Crush Project Overview

Architectural Decision Record (ADR)

• Problem: Managing cross-module event distribution cleanly without creating tight internal coupling or complex local pub/sub overhead.
• Alternatives Considered: In-memory mediator patterns vs. isolated transport infrastructure.
• Decision: Route same-module event cascades directly through the shared k9crush.events RabbitMQ exchange rather than a separate local pub/sub mechanism.
• Verification: Source-verified against Wolverine’s transport behavior (default fanout exchange, graceful no-op acknowledgment for modules without a local handler).
• Explicit Revisit Trigger: System performance degradation under high-throughput event cascades or scale constraints requiring modular separation to independent microservices.

Implementation Snippet

// Example configuration of the Wolverine exchange cascade verified against transport source
public static IHostBuilder ConfigureMessaging(this IHostBuilder builder)
{
    builder.UseWolverine(opts =>
    {
        opts.PublishAllMessages().ToRabbitExchange("k9crush.events", exchange =>
        {
            exchange.ExchangeType = "fanout";
            exchange.BindQueue("k9crush.local.queue");
        });
    });
    return builder;
}

Overview

Entry for the Google Cloud Agentic Cinema Hackathon (ClickHouse track): an agent that reads a plain-English film production schedule change and audits it against child-labor law before a production manager acts on it.

How it works

• Flow: Natural-language schedule change → Gemini reasoning (manual tool-calling loop, not a framework, so every step is inspectable) → dynamic read-only SQL against ClickHouse via a single frozen MCP tool → compliance delta calculation → structured Audit Report.
• Guardrails: The ClickHouse MCP server enforces a hard read-only boundary (SQL keyword allow/deny-listing) — the agent can query cast and labor-law data but can never write to the database. All legal facts come from queried rows, never the model’s own parametric knowledge.
• Contested-law flagging: California’s own labor code doesn’t fully agree with itself for the 16–18/school-day band (two statutes cap hours differently, one hour apart, with no statutory statement of which governs). Rather than silently picking a side, the agent surfaces this as rule_confidence: contested_interpretation, cites both statutes, and flags it for human legal review — an explicit design choice that an agent which is always confident is more dangerous than one that knows when it’s uncertain.
• Build: Two parallel git-worktree slices (compliance logic; UI/integration) built independently against a locked schema and MCP tool contract, driven by Orca, then verified by reading the actual diffs.
• Data sourcing: California labor-law rows sourced directly from primary statute/regulation text (8 CCR §11760, Cal. Labor Code §1308.7), not secondary summaries — a cross-check against the verbatim text caught a real error in an early secondary source.

Overview

A research-track masters application, building on the Level 8 Higher Diploma in Business, Regulatory Risk & Compliance completed at TU Dublin (DORA-focused, Dec 2024). Application forms submitted; currently at the admissions interview stage.

Research focus

The working thesis distinguishes three ways regulation can outpace technical reality — a timing gap, a verifiability gap, and a semantic gap — and commits to the verifiability gap: cases where compliance controls exist, but compliance with them can only be attested to, not independently verified.

• Concrete case: GDPR Article 17 (right to erasure) in event-sourced systems, where an append-only log is the system of record and the available reconciliations (crypto-shredding, PII externalization, tombstoning) are all controls nobody outside the organization can currently verify.
• Empirical piece already underway: running dpia-generator, a forked open-source Claude Skill that drafts GDPR Data Protection Impact Assessments and hard-fails its own build if a stated risk rating contradicts the underlying computed data, against a live event-sourced application (a personal project) to test whether that verifiability claim actually holds up in practice.
• Method: primary-instrument analysis (EU AI Act, ISO/IEC 42001, NIST AI RMF, DORA) classifying obligations by what they require as proof — documentary evidence, technical demonstration, or self-attestation — followed by a literature review and the empirical case study above.

Overview

A GUI-driven orchestration layer that drives whatever coding-agent CLI is already installed (Gemini CLI, Antigravity CLI) through a worktree-per-task workflow: each unit of work gets its own git branch and worktree, runs independently, and is merged through an in-app diff review loop rather than a single long-lived session.

How it’s used

• Parallel slices: Work is decomposed into file-disjoint slices up front, so multiple worktrees can run concurrently without merge conflicts — the same principle behind a hand-rolled Docker/claim-queue worker pool, but packaged with a GUI diff-review gate instead of automated test-gating.
• Human-in-the-loop merge gate: Every slice is reviewed as an actual diff before merging, not trusted on the agent’s self-reported summary.
• Sandboxing discipline: Default agent launch flags (e.g. --yolo-style auto-approval) are explicitly disabled before first use, since an unconstrained worktree does nothing on its own to limit shell or network access.
• Proven on real repos: Used as the build vehicle for the Minor Working-Hour Auditor hackathon entry (two parallel worktrees — compliance logic and UI/integration — built against a locked contract and merged independently) and evaluated as the eventual driver for AgentOS’s multi-agent phase.