Inspiration

Freelancers lose money when a client's tentative request becomes confirmed scope, or when a budget is read incorrectly. Panga helps them inspect what was actually requested before accepting a fixed-price project. For Life After Code, we focused on what happens after the application is built: keeping those behaviours correct as the code changes.

What it does

Panga turns client briefs and messages into scope with source evidence and calculates deal economics using deterministic code. It supports negotiation rehearsal and reply drafting while leaving acceptance and sending decisions to the freelancer. Our hackathon addition is a supervised maintenance loop. GitLab CI detects conversation regressions. An explicit mention triggers our custom GitLab Duo flow to reproduce the problem, propose a bounded production-code repair and open a draft merge request. We independently verify the exact candidate using tests and scripts reconstructed from a fixed, human-reviewed baseline.

How we built it

The existing MIT application uses TypeScript, Next.js, Mastra and Gemma through DigitalOcean. We imported it into the assigned GitLab Showcase project, preserving both the original project history and the Showcase starter history.

During this hackathon we added GitLab CI, twelve fictional conversation regression cases, a live evaluation runner sharing production analysis code, revision-bound reports, independent candidate verification and a custom GitLab Duo Agent Platform flow. We also corrected inferred work being promoted into confirmed scope and a budget amount matching a substring of a larger amount.

The flow is enabled with Mention as its only trigger. It uses a fixed reviewed verifier baseline and limits accepted candidate changes to selected production files. No automatic merge or deployment is performed.

Challenges we ran into

Fluent model output is not enough: quotes must match the source, tentative work must remain distinguishable from confirmed work, and budget checks must respect complete amounts.

We also had to accommodate the actual Duo runtime: project CI variables were not exposed to its jobs, and its initial checkout was main. We pinned the reviewed baseline in the flow and required a clean, uniquely named repair branch before changing code.

The hackathon permissions still allow Developer direct pushes to main. Our verifier and human-review procedure therefore do not constitute a tamper-proof permission boundary. We disclose this limitation rather than claiming complete agent isolation.

Accomplishments that we're proud of

A real Duo execution reproduced five failing synthetic conversation contracts, restored the inferred-status guard, committed a repair and opened draft MR !2. Its pipeline passed. Independent verification of the exact candidate also passed: 118 checks, production build, Temporal bundle and typecheck.

Separately, all twelve live conversation cases passed with real Gemma 4 calls on clean reviewed code, with no synthetic fallback. The deployed app also completed a real fictional-brief analysis and draft reply generation.

The demo intentionally introduced a regression, then restored the original main tree exactly. MR !2 consequently has no net file diff from main; no production merge was necessary to undo the demo regression.

What we learned

Conversation behaviour needs explicit regression contracts. An agent's proposed repair and its acceptance checks should be reviewed independently. Real runtime validation exposed assumptions that configuration review alone did not catch.

What's next for Panga

Broaden the evaluation set, improve failure triage and strengthen branch permissions where the hosting environment permits it. Keep future merges and deployments subject to human review.

Built With

  • agent
  • digitalocean;
  • duo
  • gitlab
  • gitlab;
  • mastra;
  • next.js;
  • platform;
  • typescript;
Share this project:

Updates

Submission history