Aevum

• 

  Open a GitLab issue, get a verified GPU speedup, hands-off: 6.96× with correctness passing.

• 

  Nine GitLab stages, one hands-off run", with the subtitle "issue #18 to merged MR !15: 6.96× faster, correctness passing

• 

  A GitLab Duo flow turns the issue into a performance contract: target, workload, goal, allowed and protected files.

• 

  A rented GPU and Claude Code: the live build log, check by check.

• 

  MR !15: the independent check table. Correctness passed, 6.96× faster than before, merged by itself.

• 

  The tagged release: GPU measurements, and a CUDA binary run on a real GPU before publishing.

• 

  MR !15's pipeline: SAST, secret detection and dependency scanning pass, then the governance gate says SHIP.

• 

  The main pipeline after the merge: PyPI package, binaries including CUDA, a keyless deploy to Cloud Run, and a smoke test.

• 

  Monitoring opened (and later closed) this GitLab incident by itself.

• 

  Built with GitLab Duo, Google Cloud and Claude Code.

Inspiration

In 2024 I asked the maintainer of rayshader, an open-source package I used, for GPU support. The honest answer: GPU support was "a large undertaking". I knew CUDA, but not the project. The maintainer knew the project, but GPU work was a big job. The work needed both.

Code is getting easier to write, so what matters now is what only you can do. I wanted my CUDA knowledge to help more projects than I could reach on my own, while the maintainer keeps the direction.

What it does

Aevum turns a GitLab issue that says "this is slow" into a verified, shipped speedup, hands-off:

1. Plan: a GitLab Duo flow reads the issue and the maintainer's rules (a wiki page) and posts a performance contract: target, workload, goal, the files that may change and the files that are protected.
2. Create: every 2 minutes, Google Cloud Scheduler and Cloud Run wake a private worker. It rents the cheapest NVIDIA GPU, and Claude Code improves the code check by check.
3. Verify: the AI never grades itself. An independent re-run checks correctness against known-good code and measures speed; then GitLab CI runs tests, security scans and a governance gate.
4. Ship: if everything passes, the merge request merges itself. GitLab publishes the package, deploys the demo to Cloud Run, and for tagged releases runs the compiled CUDA binary on a real GPU before publishing.
5. Monitor and remember: monitoring opens incidents; each run's chat history, code snapshots and lessons are kept privately in Google Cloud Storage, so the next run builds on what worked.

Everything is linked to the issue: the contract, the live build steps, the merge request and the result.

Why Duo plans and Claude Code builds: GitLab Duo owns intent and policy. It turns the issue and the maintainer's wiki rules into the performance contract, rewrites it when the maintainer answers a question, and posts every status and result on the issue. The verifier and the governance gate enforce that contract, so the builder is interchangeable: today it's Claude Code on a GPU, and the repo also includes a Duo builder flow (flows/aevum-builder.yml).

The run in the video: issue #18 "Point containment is too slow on big meshes" became MR !15, merged by itself: 6.96× faster than the project's code before the run, correctness passing, on an RTX 4000 Ada rented at $0.20/hr.

Try it: the judges' guide has a one-click request that runs the whole loop on your own issue.

The nine stages, with proof

Path B: what existed and what we built

Existing project: trimesh (MIT). Its upstream history up to Oct 2, 2026 was imported into our GitLab fork on Oct 20. Built during the hackathon: all of Aevum and every Aevum merge request on trimesh.

How we built it

• GitLab: a Duo flow (AI Catalog) for planning; issues, labels and the wiki as the interface; CI for verification, security scans (SAST, secret detection, dependency scanning) and the governance gate; the PyPI package registry, releases, environments and incidents.
• Google Cloud: Cloud Scheduler and Cloud Run for the 2-minute wake (it reads the public project with no token), Secret Manager, Cloud Storage for run memory, and keyless deploys through Workload Identity Federation.
• Claude Code runs on a rented GPU as the builder, inside a bounded loop: edit, check on the GPU, retry.
• Security model: the public project never holds an AI credential. A private worker owns the secrets; every command Claude runs, and all project code, runs as a separate builder user with an empty environment; Claude never gets write access; a separate publisher opens the merge request.
• The demo project is our fork of trimesh, a Python library for 3D shapes downloaded millions of times a month.

Challenges we ran into

• A failed attempt is not a broken workflow. A rejected candidate (too slow, or fast but wrong) had to feed back into the next try instead of failing the pipeline.
• Fair benchmarks. Same workload, same machine, warm-up, synchronization and medians, so every speedup is real.
• Running unattended. GPUs run out at the price cap, logins expire and usage limits hit; each case needed a clean pause-and-resume instead of a human stepping in.
• The trust boundary. Keeping the AI's credentials out of the public project while still letting GitLab drive everything.

Accomplishments that we're proud of

• A real issue became a self-merged, verified 6.96× speedup with nobody touching anything.
• Seven hands-off runs shipped, including 154.9× on signed distance, 100× on closest point and 16× on ray casting, with correctness passing every time.
• A rejected CPU idea (0.71×) was followed by a CUDA retry at 70.6×. The verifier said no, and the next attempt earned a yes.
• A self-test attacks the sandbox with a booby-trapped script, and all 15 checks pass.

What we learned

The coding model is not the product. The value is the loop around it: a clear contract, independent verification, and GitLab as the place where intent, evidence and decisions live.

What's next

• SKILL.md lets any maintainer set Aevum up on their own project.
• More hardware and more kinds of workloads beyond 3D geometry.

Built With

• anthropic
• claude-code
• cuda
• cupy
• docker
• gitlab
• gitlab-ci
• gitlab-duo
• gitlab-duo-agent-platform
• gitlab-package-registry
• google-cloud
• google-cloud-run
• google-cloud-scheduler
• google-secret-manager
• numpy
• nvidia
• python
• runpod
• trimesh
• workload-identity-federation