Google Cloud Rapid Agent Hackathon · GitLab Track

Minari実成

Autonomous flaky-test intelligence. The agent that doesn't just flag a flaky test, it fixes one.

Detect → diagnose → fix → verify → deliver. Minari proves every fix in real GitLab CI and opens a reviewed merge request. It never weakens an assertion, and never merges on its own.

5 autonomous stages<2 min detect to delivery CI-verified0 auto-merges
minari — live agent feedLive
  • ASYNCtest_async_result_ready_after_sleep94
  • RACEtest_event_order_dependent_result78
  • REStest_pool_acquire_under_contention71
  • NETtest_service_responds_within_latency_budget55
  • DATAtest_cart_total_isolation28
Ranked by flakiness risk · diagnosed, fixed & verified autonomously over GitLab MCP
DeveloperFrancis Daniel · Mizu
TrackGitLab · MCP
DeadlineJun 12, 2026 · GMT+8

Built with Gemini 2.5 · LangGraph · GitLab MCP · Google Cloud Run

Problem Statement

Flaky tests don't fail because the code is wrong.

They fail because timing, ordering, and shared state are unreliable, and that unreliability quietly erodes trust in the whole suite. Most tools can only point at them; fixing by hand is slow, and the lazy fix, weakening the test, is worse than the flake itself.

16%of tests
Flakiness is universal at scale
Google measured ~16% of its own tests as flaky. The best-resourced suite on earth still has them, and so does yours.
5+hrs / dev / week
Time lost chasing ghosts
Engineers routinely lose several hours a week re-running pipelines and bisecting failures that were never actually bugs.
0trust left
The suite stops meaning anything
After enough false alarms, teams reflexively ignore red, including the one failure that was a genuine break.

Flakiness rate from Google's published testing research; other figures are representative of industry experience.

How It Works

One trigger.
The entire repair, end to end.

Detect → Diagnose → Fix → Verify → Deliver. Five specialist agents, one LangGraph pipeline, no human in the loop until the merge request is ready for review.

Continuous data flow from a flaky run to a verified, reviewed merge request.

01
Detect
Score flakiness from history
PFS engine
02
Diagnose
Find the real root cause
Gemini 2.5 · pgvector
03
Fix
Write ranked candidate repairs
tree-sitter gates
04
Verify
Prove it in real CI, 5× over
GitLab pipelines
05
Deliver
Open a reviewed merge request
GitLab MCP

See It Run

Trigger a test.
Watch the whole repair.

Architecture

A pipeline of specialists,
not one monolithic prompt.

Five agents, each with one job and one well-defined hand-off, orchestrated by LangGraph and grounded in real GitLab and Supabase data.

Interface
Next.js dashboard · live SSE stream
FastAPI · LangGraph agent
Detect
Diagnose
Fix
Verify
Deliver
GitLab MCP
Code · CI · MRs
Gemini 2.5
Reasoning
Supabase
Postgres · pgvector
Upstash Redis
Rate limits
LangGraph agent swarm
Each stage is a node with a conditional edge. Low confidence ends the run early; a verified fix flows through to delivery.
GitLab over MCP, both ways
Minari consumes the GitLab MCP server to read code and drive CI, and exposes itself as an MCP server so other agents can call detect, diagnose, fix and verify.
Supabase + pgvector
Tests, runs, diagnoses, fixes, verifications and merge requests persist in Postgres; HNSW vector search recalls similar past failures.
Cloud-native, resilient
FastAPI on Cloud Run (Tokyo), Next.js on Vercel, Upstash Redis for shared rate limits, with graceful degradation on every node.
Gemini

LLM Integration

Gemini is the
reasoning layer.

Diagnosis, repair, and recall all flow through Gemini 2.5. Deterministic gates (syntax, assertions, real CI) own the safety. The model reasons; the pipeline verifies.

Diagnosis
gemini-2.5-pro

Deep root-cause reasoning on the uncertain cases (PFS 40–75).

Structured output → typed Diagnosis schema
Reasoning chain streamed live to the panel
Adaptive router escalates only when needed
Repair
gemini-2.5-flash

Fast generation of three ranked fix candidates (~8s).

Confidence-ranked, never edits assertions
Each candidate passes a tree-sitter syntax gate
Flash keeps the loop interactive on stage
Memory
gemini-embedding-001

768-dim embeddings power similar-failure recall.

pgvector HNSW similarity search
Surfaces past diagnoses of look-alike flakes
Grounds the model in real prior evidence
Structured output
Every model call returns a typed Pydantic schema, never free text the pipeline has to guess at.
Self-repair loop
If the model returns a malformed schema, Minari re-prompts with the validation error until it parses.
Untrusted-data fencing
Test source and logs are fenced as untrusted input, so a crafted test can't hijack the prompt.
Adaptive routing
Pro for the genuinely uncertain diagnoses, Flash for everything else: accuracy where it matters, speed elsewhere.

Features

Built to be trusted.

Assertion-safety gate
Minari fixes the cause. It never weakens the test to force a pass.

An AST walk proves every original assertion still exists in the fix. The rule is even enforced in the database, so a fix that edits an assertion can't be stored.

// fix adds synchronization, assertions untouched
+ await until(ready, timeout=2s)
assert result == expected
Syntax validtree-sitter parse
Assertions preservedAST walk · original ⊆ fixed
Assertions unmodifiedDB-enforced constraint
Real verification
Proven in real CI, five times.

The fix runs in a fresh pipeline five times; the gate demands 5/5 green plus a real drop in run-to-run variance before it ships.

Run 1
Run 2
Run 3
Run 4
Run 5
Variance reduction↓ 87%
Confidence cascade
One honest number
Detection × diagnosis × fix × pass-rate, multiplied into a single confidence on every MR.
92%overall confidence
Predictive forecast
Seven days ahead
An explainable trend model projects each test's flakiness before it breaks the build.
7-day risktrending down
Sustainability
Quantified waste
Every avoided flaky re-run counted as saved CI compute, CO₂e, and engineer hours.
1.02 kgCO₂e avoided
Human boundary
It proposes. You decide.

Minari opens a merge request with a senior-engineer write-up and a reviewer, and never merges on its own. The final call always belongs to a person.

Live reasoning
Watch it think, not a black box.

Every MCP call, decision, and fix candidate streams to the dashboard in real time.

mcpget_file_contents · test_async_timing.py
reasonrace: result read before sleep settles
fixcandidate #1 · await-until-ready
verify5/5 passed · gate PASSED

Tech Stack

Every layer, in production.

The full stack behind Minari: agent, backend, data, integration, frontend, and the security boundaries that make autonomous test repair safe to run.

Agent & LLM
Agent orchestrationLangGraph
Diagnosis reasoningGemini 2.5 Pro
Fix generationGemini 2.5 Flash
768-d embeddingsgemini-embedding-001
Agent ↔ MCP bridgeMCP adapters
Backend
RuntimePython 3.12
Async APIFastAPI
Typed schemasPydantic v2
Postgres driverasyncpg
Rate limitingslowapi
Structured logsstructlog
Live SSE streamsse-starlette
Packaginguv
Code analysis
Syntax gatetree-sitter
Multi-language parserslanguage-pack
XXE-hardened JUnitdefusedxml
Data
Primary storeSupabase Postgres
Similarity searchpgvector (HNSW)
Shared rate-limit storeUpstash Redis
Integration
Reads, CI, merge requestsGitLab MCP
Minari exposed as toolsMCP server
Frontend
App RouterNext.js 16
UI runtimeReact 19
Type safetyTypeScript
Design tokensTailwind CSS v4
Trend & forecast chartsRecharts
AnimationFramer Motion
Iconslucide-react
Diff highlightingprism
Infra & security
API host (Tokyo)Google Cloud Run
Frontend hostVercel
Python 3.12 + Node 20Docker
Secrets at restSecret Manager
HMAC API authConstant-time key
Per-run SSE authStream tokens
Hardened responsesCSP + headers

Why Minari

Others detect.
Minari completes the loop.

These are the tools teams reach for today. Most stop at detecting or quarantining a flaky test. Minari is the only one that carries it all the way to a verified, reviewed merge request.

Does it Partial No
CapabilityDatadogKatalonMergifyBuildPulseTrunkTestDinoLaunchableCopilotMinari
Detect flaky tests
Diagnose root cause
Generate fix
Verify fix
Create merge request
Free
Open source
GitLab-native
Multi-language

Positioning reflects each product's publicly documented scope as of 2026 and is meant to show category boundaries, not to disparage any tool.

Target Market

Every team with CI
has flaky tests.

Minari enters through GitLab-native teams who feel flakiness every day, expands across Git-based CI, and scales into the broader quality-tooling market. Figures are top-down estimates from public market reports.

SOM
$120M
SAM
$6B
TAM
$48B
TAM$48B
Software testing & quality tooling
The global market for test automation and developer quality tools, projected through 2030.
SAM$6B
CI-integrated test reliability
Teams on Git-based CI who feel flakiness directly, the slice Minari plugs into natively.
SOM$120M
GitLab-native orgs with active CI
The beachhead Minari can win first: GitLab teams running pipelines that flakiness already taxes.
Scaleups & platform teams
Fast-growing engineering orgs whose CI has become a daily bottleneck of red-but-not-broken builds.
Developer-experience teams
DevEx and platform groups chartered to protect velocity. Flakiness is squarely their mandate.
Open-source maintainers
Projects drowning in flaky-failure issues, where a verified auto-fix MR is an immediate relief.

Business Model

Three revenue streams.
Priced on value, not promises.

Open-core adoption seeds teams for free, a per-developer plan monetises private repos, and an outcome-based add-on ties price directly to verified fixes shipped.

$25
/ active dev / mo
01 · Open-core SaaS
Free to self-host, paid per active developer

The agent is open-core: public repos and self-hosting are free. Teams pay a flat per-developer fee for hosted runs, the live dashboard, forecasting, and the MCP server on private repos.

Free: public repos & self-host
Team: private repos, dashboard, forecast
Billed only on developers who actually push
Custom
annual contract
02 · Enterprise
Self-hosted, SSO, audit, and an SLA

Regulated and large orgs license a self-hosted deployment with SSO/SAML, audit logging, private model routing, and a support SLA. Annual contracts, seat- or org-based.

SSO/SAML + audit logs
Private model routing, data stays in-VPC
Priority support & onboarding SLA
per fix
value-aligned add-on
03 · Outcome-based
Pay only for fixes that actually verify

An optional usage add-on prices Minari on value delivered: a fee per verified fix merged. Because the safety gate ships only 5/5-green fixes, customers pay strictly for repairs that worked.

Charged on verified, merged fixes only
Inference cost is cents, high gross margin
Price scales with proven impact
Natural upgrade path
OSS / self-host
Free
Team plan
$25 / dev / mo
Outcome add-on
per verified fix
Enterprise
self-hosted + SLA

Roadmap

Live today.
Built to become a platform.

The five-stage pipeline ships verified fixes today. From here, Minari widens across languages and platforms, then shifts from repairing flakiness to preventing it.

Phase 1
Now · Live
2
Phase 2
~1 quarter
3
Phase 3
~2–3 quarters
Autonomous repair, end to end
  • Five-stage LangGraph pipeline live on Cloud Run + Vercel
  • Python / pytest with real GitLab CI verification (5× runs)
  • Assertion-safety gate + confidence cascade, never auto-merges (reviewer via blame or config)
  • Live dashboard, predictive forecast, sustainability tracker
  • Minari exposed as its own MCP server
More languages, more platforms
  • JavaScript / TypeScript (Jest, Vitest) and Go support
  • GitHub Actions alongside GitLab CI
  • Persistent MCP session to shave seconds per run
  • Org-wide flakiness analytics across repos
  • Slack + merge-request annotations on every fix
From repair to prevention
  • Forecast-driven pre-merge flakiness gating
  • Auto-quarantine with batched, scheduled fix MRs
  • Self-hosted enterprise: SSO, audit, private routing
  • Fine-tuned diagnosis on accumulated repair history
  • Shared library of verified fix strategies
Scalability
Stateless agents, serverless-ready
Each run is independent and short-lived. Cloud Run scales horizontally; Redis holds shared limits. No per-customer infrastructure to babysit.
Moat
Verification + a diagnosis flywheel
Real-CI proof and the assertion-safety gate are hard to copy. Every diagnosis enriches the similarity store, so accuracy compounds with usage.
Impact
Detection was the start, not the goal
Competitors flag flakiness; Minari removes it and is moving toward preventing it, closing the loop the rest of the category leaves open.

GitLab Track · Rapid Agent Hackathon · 2026

Stop re-running.
Start trusting the suite.

Watch Minari diagnose a flaky test, prove the fix in real CI, and open a reviewed merge request, end to end, in under two minutes.