GhostMerchant – a kill switch for AI agents that buy things

Zero-trust PayPal escrow for autonomous buyers — authorize, probe, then capture or void.

Built for the PayPal AI Hackathon. Live demo and code linked at the end.

Cartoon blue ghost holding a credit card against a dark background


The problem in one Monday morning

Priya runs Finance at Acme Cloud. Over the weekend, a deploy bug sent their purchasing agent — OpsBot — into a loop: “buy more OpenAI credits,” every thirty seconds, £800 a pop.

If OpsBot held a virtual card, Monday’s surprise is a five-figure statement and a long Slack thread.

That’s the quiet risk of agentic commerce. We’re handing software the ability to spend, often with the same instrument we’d give a junior employee: a card number in a vault, maybe a limit, not much proof that the vendor was real before the money moved.

GhostMerchant is built for the other shape of the story.


What GhostMerchant is (and isn’t)

GhostMerchant is a buyer-side control plane. It sits between your buying agents and PayPal:

  1. Policy — max order size, velocity (orders per minute), trust rules
  2. AUTHORIZE — hold funds on PayPal (not capture yet)
  3. Probe — check the vendor / deliverable looks alive
  4. CAPTURE or VOID — settle only if the probe passes; otherwise poison-pill the hold
  5. Payouts (optional) — split a successful capture across agent budget emails
  6. Dispute dossier — keep the forensic trail (policy, probe, PayPal IDs, step log)

It is not a Shopify plugin for every storefront. The merchant on the other side of the payment — a SaaS vendor, a PluginMart-style shop, anyone on PayPal — stays a normal seller. GhostMerchant doesn’t need to live in their checkout. You’re controlling your agent’s wallet behaviour once.

Business professional reviewing an AI procurement dashboard showing pending office equipment purchases and PayPal payment approval.


Three stories that explain the product

1. The honeypot vendor (VOID)

Marcus in Security at Northwind Analytics has a research agent scraping “cheap GPU API” listings. It finds a slick site selling H100 access for £15. The marketing page looks fine. The actual key endpoint is dead.

Trigger: agent fires buy.
GhostMerchant: AUTHORIZE £15 → probe vendor health → fail → VOID.
Value: Marcus gets a VOIDED session with probe proof — not a captured payment to a scam shop.
For the merchant: they never receive a capture. The auth doesn’t settle.

That’s the poison pill: money was held, not taken, and the bad vendor never got paid.

2. The healthy provision (CAPTURE)

Lena at RelayDesk wires an onboarding agent that must buy email API credits when a new tenant signs up.

Trigger: signup workflow calls purchase.
GhostMerchant: AUTHORIZE → probe “key / health OK” → CAPTURE.
Value: Lena doesn’t pay for dead keys; failed probes void and the flow can retry another vendor.
For the merchant: this is when they actually get paid — an ordinary PayPal capture. GhostMerchant stayed on the buyer’s side of the counter.

3. The human still owns PayPal

Sam at BrightPath Tutoring won’t put card PANs inside an LLM tool stack. Their content agent wants a £49 stock-footage pack.

Trigger: agent requests a hold.
GhostMerchant: creates a PayPal wallet order → status awaiting approval → Sam Approves in PayPal as the company buyer → pipeline continues.
Value: spend sits under a real PayPal identity Finance can audit (and dispute later). The agent only got permission to request a hold.


Why PayPal AUTHORIZE fits

Virtual cards are great at “can this agent pay?” They’re weaker at “should this payment settle after we checked delivery?”

PayPal’s authorize-and-capture model is closer to what agent spend needs:

  • AUTHORIZE = escrow-shaped hold
  • Probe = your policy + canary check in the middle
  • CAPTURE = merchant gets paid
  • VOID = kill switch before settlement

Add velocity limits and you also blunt the 3am runaway loop before it becomes a capture storm.

Futuristic cybersecurity illustration contrasting PayPal-authorized escrow protection with a blocked scam store transaction.


What’s in the Control Room

The hackathon build ships a single Control Room dashboard:

  • Policy sandbox (currency, max order, velocity, force probe fail)
  • Fire agent purchase (dry-run or live sandbox card / wallet)
  • Live pipeline: Policy → Authorize → Probe → Settle
  • Sessions table with PayPal IDs
  • Dossier drawer for forensics

Live sandbox paths produce real order, authorization, capture, and payout identifiers — the kind of proof judges (and future customers) can trust.


Who should care

RoleWhy GhostMerchant shows up
Finance / opsKill switch and audit trail when agents spend
SecurityProbe-before-capture against honeypots and dead vendors
Agent / platform builderspurchase behind policy instead of a raw card in the prompt
Multi-agent product ownersCapture once, Payouts split across agent envelopes

If you sell on Shopify or Stripe Checkout, you’re usually the merchant counterparty, not the GhostMerchant customer — unless you’re also running buying agents of your own.


Try it

Built with PayPal Sandbox (Orders AUTHORIZE, CAPTURE/VOID, Payouts, Disputes, Webhooks), Node/Express, and Cursor + PayPal MCP while developing.


What’s next

Post-hackathon, the natural product shape is the same API with thinner clients on top: hosted Control Room, an agent SDK / MCP buy tool, and optional Chrome or Slack “Approve / freeze” for humans in the loop. The brand stays GhostMerchant; the surfaces are just how Priya and Lena meet it.

Until then: agents can shop. Finance can sleep.

— GhostMerchant — autonomous procurement with a kill switch.

Blue cartoon ghost holding an orange credit card

The Great AI Hackathon Autopsy

When 6,000 Overcaffeinated Engineers Descended on the Void

NVIDIA Open Agent Hackathon 2026 event hall with developers coding at computer workstations beneath a large stage screen.

By the Department of Digital Post-Mortems & Existential Dread

For inspiration and proof that humans still bleed code, visit shielyule.co.uk

The digital soil is still cooling from the Great Open Agent Hackathon of late October 2026. Over 6,000 engineers from 138 countries—essentially the United Nations of sleep-deprivation—poured their collective brain-juice into 500+ production-grade submissions.

They built agents that didn’t just chat; they reasoned, they scraped, they hallucinated with enterprise-grade confidence, and above all, they participated in what hosts Samuel J. Cummings and Israel called “a master class in community management.”

Among this glorious, sleepless horde stood our own Shiel Yule, veteran of enterprise trenches and author of satirical prose, who proudly hauled in a very respectable 50th place out of 549+ entries. Not quite the podium, but high enough to avoid the absolute void of anonymity and low enough to maintain a healthy, cynical distance from Silicon Valley utopia.

Here is the autopsy of how the world tried to build production agents—and why Shiel’s entry, DealTable, managed to survive.

Phase 1: How to Vibe Code Without Summoning Demons

The rules of the Build layer were deceptively simple: build a production agent using any AI coding tool (Cursor recommended), but you must implement at least one open-source Meterless Engine into a working feature.

  • The Build-vs-Run Split: Your coding tool writes the code (using your own subscription limits), while your app’s actual brain runs on NVIDIA Nemotron through Meterless Nightshift. Do not mix them up, unless you enjoy staring blankly at 401 Unauthorized errors while questioning your life choices.
  • The Engines:
    • H-MEM for persistent memory.
    • Markovian for long-running tasks in bounded steps.
    • World Model for shared state where parallel agents can silently overwrite each other’s work.
    • Scout Intent for routing your existential panic to the correct tool.

Shiel’s response to this? Build DealTable (dealtable-webmcp.vercel.app)—a practice negotiation room where an AI counterparty (powered by NVIDIA Nemotron via Nebius Token Factory) tries to fleece you, Tavily checks if the market rates are real, and a Human-in-the-Loop (HITL) waiver gate stops the agent from selling your grandmother’s furniture to pay a commercial landlord.

Illustration of a programmer consulting a friendly AI while a shark in a suit pitches an acquisition, contrasted with a glowing human approval shield and ethical design principles.

Phase 2: Power, Lanes, and the Holy Grail of the DGX Spark

If Build is where you sweat, Power is where you pray.

Participants had to hook up Meterless Nightshift as a primary AI provider and assign models to racing lanes:

  • Lane 1 (Fast Worker): nvidia/nemotron-3.5-lightning-30b-a3b—for quick responses and snappy retorts.
  • Lane 2 (Deep Worker): nvidia/nemotron-3-super-120b-a12b—for complex reasoning, deep corporate scheming, and second-guessing your life choices.

The ultimate prize? An NVIDIA DGX Spark—a piece of hardware so powerful it probably has its own gravitational pull and minor deity.

Who took home the crown for Best Use of NVIDIA Nemotron and doubled down by winning the whole show? None other than Proof of Stage, who apparently entered the arena, rewrote reality, and spun the block twice for good measure. Salute to the legends.

Illustrated scene of a developer opening a secure ENV vault beside AI agents, servers, a satellite, and Earth, highlighting privacy and human control.

Phase 3: The Honorable Mentions & The Madness of the Modern World

While 6,000 people were busy saving the world, judge Michael Haye highlighted projects that perfectly captured the dystopian-yet-practical flavor of our current timeline:

  • Pocket Money (404 Media): An agent designed to answer the ultimate existential question for college students: “Can I afford a bus ticket home for Christmas, or should I live in the library until spring?”
  • Domino (Team Derp): A tool that analyzes code changes to prevent another global IT apocalypse (shoutout to Cloudflare and CrowdStrike for making airport shutdowns a recurring aesthetic).
  • Day Zero: A medical discharge translator that takes incomprehensible hospital release papers and turns them into plain language, reducing your post-hospital existential dread by roughly 12%.

And let’s not forget the incredible track winners tackling real-world planetary pain:

  • Sky Ledger: Using satellite data to hunt down corporate methane leaks.
  • Green Trace (Amy): Checking cocoa supplies against EU deforestation regulations.
  • Foserto: Helping regional fire coordinators decide which wildfires to fight first when the elements decide to consume civilization.

Fielding an entry that landed comfortably in the top 10% (50th out of 549+), Shiel’s DealTable stands as a monument to what happens when you combine clean Next.js/React architecture, Nebius-hosted Nemotron, Tavily search grounding, and an unshakeable belief that agents should propose, but humans must hold the floor.

As Samuel J. Cummings wrapped up the stream with a promise of round two, the lesson of the 2026 Open Agent Hackathon remains clear: we are building an army of autonomous software entities to manage our healthcare, our code reviews, and our commercial leases. Just make sure you keep your .env file in .gitignore before the singularity arrives.

Stay tuned. The machines are learning, but Shiel is still writing.

Certificate of participation for Shiel Yule in the GenAI Open Agent Hackathon 2026, featuring a futuristic robot and cursor graphic.

Truce – Agents With Taste for Divided Tables

There is a very specific domestic horror that arrives with the second bottle of Pinot Noir. Someone mentions a headline. Someone else bristles with the defensive ferocity of an automated perimeter fence. Within ninety seconds, the dining room undergoes spontaneous nuclear fission into two incompatible media ecosystems that share a postcode, a tax bracket, and absolutely nothing else.

A woman in an orange high-visibility vest holds a steaming dish while standing at a dining table. Seated around the table are men in military-style uniforms and suits, with one displaying a sign that reads 'DOUGH BUTTON'. An electronic device displaying sound wave graphics is on the table, amidst plates of food and drinks.

The wine keeps circulating. The cold sweat sets in.

Standard large language models react to this with the terrified posture of a corporate HR drone—hallucinating an anodyne “middle ground” that instantly vaporises upon contact with an uncle who mainlines conspiracy feeds and a cousin whose moral compass is calibrated entirely by broadsheet commentary. They offer platitudes; what the table actually needs is an armistice.

Enter Truce, hacked together over a feverish two days for the Qloo Agentic Hackathon.

Rather than begging ideological combatants to shake hands over the ballot box, Truce relies on Qloo’s entity-backed taste graph to map the cultural subterranean. It uncovers the real entities both tribes secretly worship, serving up a nostalgic parlor game before anyone can reach for the carving knife.

Two men seated at a diner table, one reading a newspaper and the other lost in thought. The diner has a retro aesthetic, illuminated by neon signs outside and a display screen mentioning 'BRIDGE FOUND: FLEETWOOD MAC.' A plate of fries sits on the table.

Sedating the Living Room

Feed two opposing signal sets into Qloo’s Insights engine, and the graph doesn’t preach compromise. It simply illuminates the forgotten clearing where both echo chambers overlap: high-affinity, apolitical relics like Tom Petty, Van Morrison, and the Traveling Wilburys. It turns out that underneath our algorithmic radicalisation, we are all just hostages to the exact same classic rock radio loops.

I had briefly considered building a digital mortuary assistant called The Wake—an automated cultural executor for our digital afterlives. But the horror of Sunday lunch felt far more pressing. When an API gives you genuine cross-domain affinity instead of synthetic empathy, the product decision writes itself.

The Anatomy of a Ceasefire

Truce treats dinner table diplomacy not as a moral crusade, but as an exercise in host survival:

  • Two Taste Tables: Input the ambient media diets, cinema vices, and cultural fodder of your guests.
  • The Bridge: Qloo computes the overlap across real, scored entities—leaving the hollow civic platitudes behind.
  • The Truce Deck: A rapid-fire Love / Hard Pass card game that gamifies surrender until common ground is violently locked.
  • The Diversion: Swaps out ideological debate for sensory memory prompts (“Who showed you this record first?”). The room argues over a chorus instead of the social contract.

Under the hood: Node, Express, a crisp typographic wrapper (Syne / Fraunces / IBM Plex Sans), and strict serial queues with 429 backoff—because nothing breaks a fragile cultural ceasefire quite like an unhandled rate limit masquerading as an existential void.

Truce doesn’t pretend to fix the broken machinery of human discourse. It merely slips an algorithmic sedative into the punch bowl, queues up Jackson Browne, and gives humanity twenty uninterrupted minutes to pass the gravy in peace.

Countermark: Retaliatory Automation for the Weary Consumer

Logo featuring a shield symbol with a checkmark inside, accompanied by the word 'Countermark' below.

Let’s be honest: modern billing departments aren’t trying to resolve your queries. They don’t have to. Why would they hire humans to negotiate with you when they can unleash tireless, infinite loops of automated, algorithmically generated final-adjustment notices, post-relocation “ghost charges,” and predatory demands for gym memberships that have outlived your interest in fitness by several geological eras?

They know that eventually, you will suffer from a very natural, very human condition: bureaucratic exhaustion.

The asymmetric warfare of the modern economy relies on this exact friction. They have automated, multi-tiered siege machines of billing software. You have a blank email draft, an unmonitored noreply@ address, and a vague, fading sense that what they are doing is probably illegal. Most of us eventually pay up just to buy back our peace of mind from the collection agencies.

After my own recent soul-crushing relocation—where I found myself buried under a flurry of ghost charges and aggressive demand letters for accounts I had painstakingly closed months prior—I spent countless, irreplaceable hours of my life hunting down Escalation Contacts and verifying physical addresses.

I decided I was done playing defense. That is why I built Countermark at my latest hackathon. It is automation backfire for the weary.

TRY IT OUT:

Here is the illustration of the asymmetric billing war I survived, and what we’re trying to claw back with Countermark.

What is Countermark?

Countermark takes hours of stressful, manual detective work and turns it into a structured, ready-to-send dispute draft in about two minutes. Think of it as a tactical shield to meet their billing spear.

  • Notice Ingestion via Paste or Upload: Drop raw dispute text, paste frantic emails, or upload PDF billing notices directly. It extracts reference numbers, disputed amounts, and timeline data with no hesitation.
  • Smart Recipient Detection with Confidence Badges: It trawls the notice and looks at domain heuristics to isolate the most likely destination for your pushback. Since companies hate transparency, it stamps a candid, honest Confidence Badge (High, Inferred, None) alongside cautionary warnings when the target looks like an automated role-based graveyard.
  • Curated Consumer & Regulatory Links: It pairs your dispute with category-mapped, statutory consumer support pages, ombudsman bodies, and dispute resolution schemes, so you know exactly which higher power to summon.
  • Dual Dispatch Workflow: Hit mailto: to launch a structured, plain-language dispute draft in your default email client, or copy plain text in one click to insert directly into secure consumer portals.

The Blueprint

Countermark is built on Next.js, leveraging Google Gemini to handle multi-modal document extraction and draft generation.

We feed Gemini raw text or uploaded PDF notices. It cuts through unpredictable digital layers and multi-column layouts to extract contact endpoints and build an assertive, fact-based dispute draft. By integrating standard mailto: encoding alongside clipboard fallbacks, we solved the age-old problem of getting this payload safely to where it hurts them.

The Technical Graveyard (Challenges We Ran Into)

  • Gemini Latency and 503 Spikes: Throwing giant, chaotic PDF documents at Gemini during peak API traffic occasionally led to the dreaded 30–90 second processing lag or upstream 503 errors. We spent a good deal of time engineering robust loading states, UX reassurance, and retry cycles.
  • Messy PDF Parsing: PDF format should be illegal. Multi-column billing statements, scanned receipts, and broken digital text layers made clean parsing feels like decoding dead languages. It forced us to become meticulous with schema definitions and parsing constraints.
  • mailto: URI Limits: When your dispute is heavily itemized, it can push against the hard length limit of traditional browser and email client protocols. The dual handoff (mailto vs. markdown/plain text) became our fallback to bypass this digital bottleneck.
  • Managing Token Burn: Balancing API spending and prompt prototyping on unpredictable file sizes required strict guardrails to prevent an ironic, massive cloud billing crisis of our own.

Accomplishments that we’re proud of

  • An Honest, Grounded UX: No AI magic-talk here. Just honest confidence badges, realistic status pills, and direct warning labels that keep the human completely in control.
  • Defeating the Blank-Page Paralysis: Going from a threatening billing statement to a professional, cold, defensive dispute letter takes seconds, giving stressed people an instant handhold.
  • Slick Fallbacks: Bypassing client-side URI encoding limits so you can confidently grab clean text to slam into portals when desktop mail fails.
A glowing digital shield icon featuring circuit patterns and document symbols, positioned above a black keyboard, representing cybersecurity.

What We Learned (or, Survival Guide)

Planning schema and data boundaries on day one saves countless architectural refactors. Pair with your AI as a dedicated sounding board for edge cases, and most importantly: when users are stressed, honesty beats promise. Rotating copywriting and progress indicators build more trust than over-promising automation.

What’s Next?

We want to build local dispute histories to help track deadliness right from your own privacy-conscious storage. We are actively expanding the directory of independent ombudsman escalation targets, sector-specific presets (formal, cancellation, debt proof), and batch ingestion.

Until then—don’t let the automated bill machines wear you down. Try it out, check the code, and start fighting back.

ComplaintPath – The Bureaucratic Panopticon Will See You Now

There is a distinct, rhythmic cadence to the collapse of late-stage civilization, and it rarely sounds like a meteor strike. More often, it sounds like the muffled, rhythmic thud of a high-speed printer devouring its three-hundredth successive “Final Response” letter, while somewhere in a windowless server farm in Slough, an autonomous corporate chatbot develops an existential crisis and begins filing complaints against its own motherboard.

A hand pressing a stamp marked 'WRONG DOOR' on a legal document labeled 'Petition for Jurisdictional Review', with digital displays indicating a rejection due to jurisdiction issues.

Welcome, dear reader, to the gleaming, algorithmically-lubricated labyrinth of modern UK consumer redress. If you have ever tried to dispute a rogue energy bill, extract a refund from a high-street bank that appears to view your capital as a personal venture fund, or inform a data controller that their cookie banner is roughly as legally compliant as a pirate radio station broadcasting from a North Sea oil rig, you will already know the drill.

You enter the Maze. You choose between three dozen distinct Ombudsmen, each possessing the administrative flexibility of a medieval drawbridge operated by a melancholic monk. You feed your grievances into a chatbot trained exclusively on corporate deflection poetry. And slowly, agonizingly, the statute of limitations bleeds out in a puddle of automated sympathy links.

It is beautiful, really. A masterclass in friction-as-a-service.

Enter ComplaintPath: Because Someone Had To Teach the Machines How to Say “No” With Precision

Naturally, when the good people at GenAI.works rolled out Track 01 of the #OpenAgentHackathon—Solving Fragmented Intelligence—we took one look at this bureaucratic abattoir and thought: What this desperately needs is more artificial intelligence.

Specifically, we built ComplaintPath.

It is not legal advice. It is not a ambulance-chasing claims company operating out of a caravan park in Lanarkshire. It is a cold, hyper-rational multi-agent pipeline designed to stare unflinchingly into the abyss of corporate rejection letters, check the statutory clock, and either open the exact right statutory door or politely, unblinkingly inform you that you are entirely out of luck.

You remain in total control. The machine prepares the ammunition; you pull the trigger. We never auto-file, primarily because giving an AI unmonitored access to the Financial Ombudsman portal feels like handing a toddler the launch codes to a Trident submarine.

Under the Hood: A Symphony of Corporate and Silicon Indifference

To build a machine capable of navigating the labyrinth without hallucinating a statutory deadline into existence, we had to enlist a rather formidable stack of sponsors who clearly share our dark appreciation for automated systems:

  • Zetaris (The Data Layer): Redress windows and portal URLs are not buried deep within some hallucinatory prompt hallucination. On every analysis run, our DataRetrieverAgent queries Zetaris live for the brutal, unvarnished truth of the scheme windows. In the product interface, it proudly declares Scheme data: Zetaris live. No fairy tales; just raw, relational architecture doing what bureaucrats pretend to do.
  • Meterless Nightshift & NVIDIA Nemotron (The Power): Letter comprehension runs through Meterless Nightshift on a dedicated Nemotron lane. It extracts facts with the icy detachment of a seasoned coroner. If a date is missing, the AI does not invent one—it simply stares at you with quiet disappointment.
  • Meterless World Model (The Cognition Engine): Every shared run state, entity, observation, and provenance trace lives here, ensuring that when the audit trail is requested, we can explain precisely which agent decided your complaint was six days too late.
  • Bright Data (The Web): When drafting pack section IV, Bright Data’s Web Unlocker refreshes context straight from the official scheme portals, ensuring our guidance doesn’t drift into folklore while you’re making a cup of tea.
  • Cursor (The Crucible): Scaffolding and shipping an entire multi-agent civic UI, adapters, gates, and PDF exporters in record time without throwing your MacBook out of a third-floor tenement window.
  • GenAI.works (The Arena): The wonderful madhouse that gave us the window to build Track 01.

The Four Horsemen of the Gate

When you feed a corporate refusal letter into ComplaintPath, the system reduces the boundless bureaucratic horror of modern Britain down to four immutable, code-enforced outcomes:

  1. Eligible: You may proceed. The system compiles a pristine markdown and PDF pack for you to take to the official portal.
  2. Premature: You jumped the gun. The corporate monolith is still legally permitted to ignore you for another eight weeks. Go back and wait in the dark.
  3. Out of Time: The clock has run out. The statute of limitations has turned your grievance into historical artifact. Pour one out for your lost consumer rights.
  4. Wrong Door: You are screaming at an energy supplier about a parking fine. The machine will gently redirect you before you embarrass yourself further.

The next step after download is wonderfully pedestrian: log on to the designated official portal, drop in your Gate Pack, and let the grinding wheels of statutory justice grind exceeding small.

Examine the Evidence

If you fancy auditing our descent into civic automation, or if you simply want to fork a repository that treats corporate obfuscation with the contempt it so richly deserves, the doors are wide open:

A tip of the hat to Zetaris, Meterless, NVIDIA, Bright Data, Cursor, and GenAI.works for providing the raw materials required to construct our little digital panopticon.

ComplaintPath is independent guidance software. It does not provide legal advice, and it certainly won’t save you from the heat death of the universe. But it might just help you get your £48.50 back from your broadband provider before the ice caps finish melting.

Podcast Episode: Undo – The Ghost of the Past Package

Pip: Shiel Yule has a question for your CI pipeline, and it is not the one your pipeline has been asking itself.

Mara: Today we’re covering a hackathon project that challenges a core assumption in modern software delivery — that a green build means you’re safe to ship.

Pip: Spoiler: it does not.

Mara: Let’s start with the project itself, and why rollback verification changes the picture entirely.

Undo – The Ghost of the Past Package

Pip: Here is the tension at the center of this project: most pipelines only look forward. They ask whether the new build works. Nobody asks whether the previous one still can.

Mara: The post puts it plainly — “Most pipelines only ask one question: Does the new build work? It’s a polite, forward-looking question. It’s optimistic. It’s hopelessly naive. In a real-world incident, the question that actually makes your stomach drop into your boots is far more brutal: Can we still run what we had before?”

Pip: That is the gap Undo is built to close. If you cannot prove the previous artifact still boots, your rollback plan is a theory, not a capability.

Mara: The project was built as a GitLab Life After Code hackathon entry. The loop it implements has four steps: Prove, Ask, Approve, and Promote. On every push to main, GitLab CI resurrects the previous package and hits a health endpoint — specifically a rollback verification check — before anything else moves forward.

Pip: And the Ask step is where it gets interesting. An event-driven GitLab Duo flow triggers automatically on pipeline success, reads the rollback proof, and opens a Work Item. No chat interface, just structured automation responding to a real signal.

Mara: The Approve step is deliberately minimal — one word from a human. The post is explicit about why: “even in an age of autonomous silicon agents, a human being should still be the one holding the smoking revolver when production goes sideways.”

Pip: A green pipeline on a laptop is, in the post’s words, “just a comforting delusion.” The Google Cloud infrastructure — service accounts, Cloud Build, Artifact Registry, and Cloud Run — is what gives the verification somewhere real to land.

Mara: The post closes with three principles worth keeping: event-driven flows beat chat demos, green is not the same as safe to promote, and a human still owns the final decision. The project repository, live demo, and Devpost submission are all linked for anyone who wants to inspect the pipeline directly.

Pip: Which means the corpse is available for prodding at your convenience.


Mara: The core idea here is durable — verification is not the same as validation, and rollback is not a fallback if nobody has tested it.

Pip: Next time, we find out what else the pipeline has been quietly assuming.

Undo – The Ghost of the Past Package

Why Your CI Pipeline is a Corporate Séance

A vintage, steampunk-inspired keyboard featuring a prominent red 'APPROVE' button, alongside a steaming mug of Earl Grey tea. A handwritten note warns, 'The previous package is still breathing. Do not wake it.'

Let’s be honest about how software delivery actually works in the wild.

For decades, the enterprise software ritual has followed a comforting, highly choreographed liturgy. You write some code. You sacrifice a chicken to the Jenkins gods. The CI pipeline turns green—a soothing, celestial lime-green glow that whispers sweet nothings into your ear, assuring you that all is right with the universe.

And then you deploy to production, and the server spontaneously combusts into a heap of weeping stack traces, leaving you frantically rummaging through the digital equivalent of a burning attic trying to find last Thursday’s release artifact.

Because here is the dirty little secret that the agile certifiers don’t want you to know: Most pipelines only ask one question: Does the new build work?

It’s a polite, forward-looking question. It’s optimistic. It’s hopelessly naive. In a real-world incident, the question that actually makes your stomach drop into your boots is far more brutal: Can we still run what we had before?

A stylized logo featuring a geometric fox design within a shield, accompanied by a green checkmark, set against a dark digital background.

Enter Undo: Necromancy for Cloud Run

That specific brand of existential dread is what birthed Undo—my entry for the GitLab Life After Code / Transcend hackathon over on Devpost.

The premise is delightfully cynical. Instead of blindly trusting that tomorrow’s shiny container image won’t accidentally erase your user database and summon ancient Sumerian demons into your AWS/GCP VPC, Undo implements a strict regime of digital necromancy.

It runs on a simple, ruthless loop:

  1. Prove: On every push to main, GitLab CI doesn’t just build the new toy; it resurrects the previous package, forces it to look into the mirror, and hits /health (ROLLBACK_OK) to verify it hasn’t lost its mind.
  2. Ask: If the past is still breathing, an event-driven GitLab Duo flow (no chat-theatre chatbots, just cold, hard automation) triggers automatically on pipeline success, reads the rollback proof, and opens a Work Item.
  3. Approve: I reply with one word: approve. (Because even in an age of autonomous silicon agents, a human being should still be the one holding the smoking revolver when production goes sideways).
  4. Promote: A manual promote_production job ships the exact same verified image out to the world.

You can prod the corpse yourself right here: Undo Live Health Check.

Why GitLab and Google Cloud Made the Séance Possible

This wasn’t about building another clever wrapper chatbot that hallucinates python scripts while you sip your flat white. This was about life after code: verification, packaging, release, configuration, and governance.

GitLab became the spine—handling everything from the single .gitlab-ci.yml file to the staging gates and agent session history where judges can peer into the machine’s little mechanical soul.

And Google Cloud? That was the missing proof. A green pipeline on a local laptop is just a comforting delusion. Wiring GitLab CI directly into GCP—service accounts, Cloud Build, Artifact Registry, and Cloud Run—meant the app had somewhere real to land. It stayed tiny and razor-focused on the lifecycle, because when you’re staring down an infrastructure failure, you don’t need a bloated UI; you need to know if the last thing that didn’t break can still boot up.

The Builder’s Post-Mortem

If you’re diving into the next hackathon or trying to drag a legacy enterprise kicking and screaming into supervised autonomy, keep a few hard-earned truths in mind:

  • Event-driven flows beat chat demos. Stop chatting with your agents; make them trigger on structural events like pipeline passes and leave an audit trail that won’t disappear when the Slack tab closes.
  • “Green” is a polite fiction. A green pipeline does not mean “safe to promote” until you have physically verified that the previous artefact can still answer the phone.
  • Keep a human on the tripwire. Agents and CI can handle the heavy lifting in the middle, but a human still owns the final, glorious privilege of pushing the button.

Undo’s rule is simple, brutal, and effective: Don’t treat the next package as ready until the last one still boots—and don’t promote until a human says so.

A dimly lit, dilapidated room with overgrown plants and moss. In the center, a server rack displays the message 'ROLLBACK_OK'. The room features broken windows allowing rain and mist to enter, with an old sofa and table in the corner.

Life After Code: building “undo” with GitLab, Devpost, & Google Cloud

Most pipelines only ask one question: does the new build work?
In real incidents, the question that hurts is different: can we still run what we had before?

Logo for Undo, featuring a stylized fox and shield design with the word 'undo' in light blue and the phrase 'Supervised Deployments' underneath in smaller text.

That idea became Undo — my entry for the GitLab Life After Code / Transcend hackathon on Devpost. It’s a small app with a big lifecycle: prove the previous package still boots, ask a human to approve, then promote to Google Cloud Run.

What Undo does

On every push to main, GitLab CI:

  1. Tests and packages the exact build
  2. Starts the previous package and hits /health (ROLLBACK_OK)
  3. Builds an image, runs Cloud Build into Artifact Registry, and deploys staging on Cloud Run
  4. A custom Duo flow — Undo — triggers on pipeline passed, reads the rollback proof, and opens a Work item (PASS or FAIL)
  5. I reply with one word: approve
  6. A manual promote_production job ships the same image to production

Live health check: https://undo-pjcvzfkkzq-nw.a.run.app/health

Supervised autonomy in practice: agents and CI do the middle work; a person still owns the final call.

Why GitLab made this possible

This hackathon isn’t “write a clever chatbot.” It’s about life after code — verify, package, release, configure, govern — with Duo Agent Platform in the loop.

What stood out for me:

  • Pipelines as the spine — one .gitlab-ci.yml from test through staging and a visible promote gate
  • Duo flows, not chat theatre — Undo runs on Pipeline events → Passed, then posts a Work item. No prompt from me mid-demo
  • Everything in one place — code, packages, jobs, issues, and the agent session history judges can click through
  • GitLab wasn’t just the host repo. It was the product surface I was building on.

Why Devpost helped (more than “submit here”)

Devpost keeps a solo hackathon sane: clear Path A / Supervised rules, a place for the story, try-it-out links, and a video deadline you can’t ignore.

The structure forced me to explain Undo the way judges will see it — not as a pile of YAML, but as a loop: prove → ask → approve → promote. That clarity made the build better, not just the form.

If you’re entering: treat Devpost as a design brief, not a last-minute paste box.

Why Google Cloud was the missing proof
A green pipeline is nice. A public URL is better.

Wiring GitLab CI to Google Cloud — service account, Cloud Build, Artifact Registry, Cloud Run staging and production — meant anyone can open /health and see the version we just approved. That’s the Google Cloud bonus path done properly: deploy config in the repo, human still on the gate.

Cloud Run gave me somewhere real to land. The app stayed tiny on purpose so the story stays on the lifecycle, not a fake product UI.

  • What I’d tell another builder
  • Event-driven flows beat chat demos for this challenge
  • “Green” ≠ “safe to promote” until the previous artefact still answers
  • Credits, group projects, and CI variables are part of the craft — budget time for them
  • Ship a live URL if you can; it turns “I deployed” into “click this”


Links

Project (GitLab): shielyule-group/ShielYule-project
Live demo: https://undo-pjcvzfkkzq-nw.a.run.app/health
Hackathon: GitLab Life After Code on Devpost
Video: https://youtu.be/dI7f7ozZu6Y

Huge thanks to GitLab for the platform and the brief, to Devpost for a submission experience that keeps builders honest, and to Google Cloud for a place to prove the promote step in public.

Undo’s rule is simple: don’t treat the next package as ready until the last one still boots — and don’t promote until a human says so