Duo Strace: Auditing AI Agents

Which files did it read first? Why did it call the same tool three times? What failed before it found the fix? Duo Strace answers every question with immutable traces.

Comment

Inspiration: The Autonomous Agent Black Box

When AI agents work autonomously—fixing bugs, reviewing code, generating deployments— you lose visibility. You get the result but not the journey.

The Problem: Most teams deploying autonomous agents face the same challenge:

  • Zero auditability: "How did the agent make this change?"
  • Missing ground truth: No log of what files were read, which tools were called, what decisions failed
  • No decision memory: Similar issues resurface because past agent reasoning isn't captured
  • Compliance gaps: Enterprise teams can't prove correctness to auditors or reviewers

What We Built

Duo Strace is an enterprise-grade observability system for GitLab AI agents. It captures the entire agentic session—not just outputs, but the complete decision trajectory.

The 4-Agent Orchestration:

  1. Diagnostician – Understands root causes, logs reasoning
  2. Code Fixer – Generates fixes with confidence scoring and historical solution queries
  3. Deployer – Validates via test-gated MRs
  4. Trace Writer – Synthesizes all decisions into immutable GitLab issues with full causal logic

When a pipeline fails, all 4 agents automatically activate, fix the problem, validate it works, and post a complete deterministic trace—an immutable, replayable record of every decision.

How We Built It

  • YAML-based agent definitions for extensibility and version control
  • GitLab-native flows for orchestration (no external systems required)
  • Immutable trace artifacts stored as GitLab issues with full decision replay
  • Decision memory loop – Code Fixer queries past traces to reuse solutions
  • Test-gated MRs ensure no regressions before merge

Key Innovations

✅ Deterministic Traces – Every tool call, decision branch, error recovery is logged ✅ Decision Replay – Reviewers can understand exactly why the agent chose a fix ✅ Compliance Ready – Immutable audit trails for regulatory and security teams ✅ Self-Learning – Agents improve by querying past trace history ✅ Extensible – Build custom agents for your specific automation needs ✅ Enterprise Grade – Works entirely inside GitLab, no external dependencies

What We Learned

  1. Enterprise teams prioritize auditability over speed—transparency builds trust
  2. Decision replay is more valuable than code—reviewers want to understand reasoning
  3. Test-gated automation removes risk—validation before merge is non-negotiable
  4. Immutable traces unlock continuous learning—agents solve recurring problems faster

Challenges & Solutions

Challenge: How to capture complete decision flow without slowing down agents? Solution: Strict prompt contracts requiring agents to pass reasoning forward, not just outputs

Challenge: Making traces useful for reviewers without overwhelming them? Solution: Structured trace format with decision causality, confidence scores, and one-click MR review

Challenge: Scaling agent orchestration across teams? Solution: Public agents and flows—teams share domain expertise via reusable components

Impact

  • Autonomous at Enterprise Scale – Full visibility and auditability for confident agent deployment
  • Friction Removed – Developers get working code instantly, with complete transparency
  • Compliance Satisfied – Immutable traces prove correctness for audits and reviews
  • Continuous Learning – Agents improve via historical trace memory on recurring problems

Built With

  • duo
  • gitlab
  • yaml
Share this project:

Updates