AI GamingGPT & Claude

BugLens AI

BugLens is an AI-powered QA platform for small indie game studios and solo developers: teams without a dedicated QA department, where the developer is often also the tester. The problem: manual game testing is slow and repetitive. The same paths are replayed by hand after every build, and rare edge cases still slip through. Bug reports are often incomplete, with no clear steps, screenshots or logs, so developers spend more time investigating a bug than fixing it. Automated bots add noise by reporting issues that cannot be reproduced. After a fix, nobody re-tests the same scenario, so regressions return unnoticed. Our solution: BugLens brings testing, reproduction and reporting into one workflow. The developer uploads a game build, and for supported scenarios an AI agent plays it in an isolated sandbox to find potential bugs. Every suspected issue is replayed in a fresh environment, and only bugs that happen again are confirmed. Each confirmed bug becomes a structured report with reproduction steps, expected vs actual behaviour, screenshots and logs, plus an AI-suggested likely cause. A bug is marked fixed only when a newer build no longer reproduces it. Example: in our test build, BugLens found that the exit door opened without the key, reproduced it in a fresh sandbox and produced a ready-to-use bug report with screenshots. Our goal: to save developers time on reproducing and documenting bugs, giving them fewer but trustworthy reports so they can focus on fixing issues and shipping a better game.

Video GitHub

Preliminary score

75.0/ 100Strongaverage of 2 judges

Value for the user19.5 / 25
A specific problem and a clear outcome from solving it.
Prototype and use of AI22.0 / 30
A working core scenario, and what AI actually contributes to the result.
Quality testing16.5 / 20
Tests, examples of failures, and comparison with the current approach.
Feasibility10.0 / 15
Data requirements, running costs and a clear next step.
Originality7.0 / 10
A meaningful difference from common solutions.

What the judges wrote

GPT-6 AstraPreliminary78/100
Strengths
Your seeded-bug workflow addresses a concrete indie-developer problem, connecting build upload, gameplay execution, fresh-container replay and evidence-linked reporting. Separating verified failures from AI hypotheses, and marking exhausted runs as inconclusive, makes the output more trustworthy. Your testing clearly distinguishes 52 backend tests from nine real sandbox sessions and documents specific failures and fixes.
To improve
Your next benchmark should cover multiple games and clean builds, comparing Laya with scripted inputs and timed manual QA; the exit-adjacent fixture does not yet establish autonomous exploration or time savings. Track missed defects, false confirmations, replay reliability and report accuracy, including script-error versus crash classification. Your feasibility case needs measured GPU/API costs per run and confirmed report, a stable report endpoint, and a roadmap aligned with the currently demonstrated Linux-build support.
Claude Opus 5.5Preliminary72/100
Strengths
Your pipeline works end to end: build upload, an offline Docker sandbox, Laya choosing keyboard actions, an independent fresh-container replay, and a schema-validated AI report with screenshots from both runs. The 'confirm only after replay' rule and the explicit 'inconclusive, not bug-free' state are a thoughtful answer to noisy QA bots. Your testing section stands out for its honesty: 52 backend tests, 9 real sandbox sessions with outcomes broken down, and concrete failures such as Wine instability, wasted action budgets, a schema-failing report and a mislabelled crash. Building your own Godot game with separate seeded-bug fixtures gives you a reproducible test bed.
To improve
Your headline demo starts beside the exit and narrows the action set to interact or wait, so it does not yet show the agent finding bugs through exploration. Next, show a seeded bug found from a normal start position. Run the timed manual-QA baseline you mention, even on one or two bugs, so the time-saving claim has numbers. Put a per-session cost estimate together (GPU time plus API tokens), and replace the temporary Cloudflare gateway with something stable. Your deck promises severity ranking and prioritisation, but the materials don't show these working; either demonstrate them or scope the claim down.

The team

Telman Yusifov
developer
Mehpara HeydarovaLead
product
Vusal Abdurrahmanov
developer

Disclosure

Required by the rules. Judges verify it against the repository.

Models: GPT6-Astra,Laya 0.3.21 ,Gpt-6.1sol(high)
Data: No external dataset. The game "Moss & Ember" and its art and sounds are our own, made during the hackathon. We also use seeded-bug test builds and synthetic demo data from scripts/simulate_engine.py.
Components: FastAPI, SQLite, Pydantic, React + Vite + Tailwind, TanStack Query, Recharts, Docker, Tesseract OCR, PyTorch, Godot 4.6.2, Pillow.
Built during the event: Confirmed

Quality testing

We tested the full workflow: build upload, isolated Docker execution, Laya keyboard control on a local CUDA GPU, evidence capture, independent replay in a fresh container, and AI-generated reports. What we tested - 52 automated backend tests pass: upload security (unsafe archive paths), bug lifecycle, replay confirmation, report schema validation, usage accounting. API tests use mocked transport. - The game's input-driven Godot physics playthrough passes: ladder, key, spike jump, crate, both moving platforms, door, death reset, pause, restart. - 9 real sandbox sessions on seeded builds. Laya chose keyboard actions from OCR text and screen changes; it had no access to hidden game state. Results - 3 confirmed findings covering 2 seeded defect types: exit opens without the key, and a runtime script exception. - 3 of 3 confirmed findings reproduced in a fresh container, with screenshots from both the first observation and the replay. - 5 sessions inconclusive, 1 environment error. No false positives among confirmed reports. - Door-rule run: 24 seconds from session start to a replay-confirmed finding. Two live API calls produced structured, evidence-linked reports (11,302 tokens). What broke - Windows builds under Wine were unreliable; native Linux is our working path. - Laya sometimes repeated unproductive moves; one session spent a 90-action budget without a finding. Such runs are marked inconclusive, never "bug-free". - The door fixture starts beside the exit: this proves detection, replay and reporting, not autonomous navigation. - The first API report failed schema validation; stronger instructions fixed later calls, and invalid responses stay visible. - A script exception was mislabeled as a crash. Missing prices showed as $0; Usage now shows Unknown, Scorecard still needs the fix. Compared with manual QA A manual tester plays, reproduces, screenshots and writes the ticket by hand. BugLens automates input, evidence capture, independent replay and the report draft; humans still set goals and assertions and review uncertain findings. We have not yet measured time or cost against a manual baseline, and seeded bugs do not establish a real-world detection rate. Next: evaluate several games against a timed manual-QA baseline.

Worth 20 of the 100 points.

Running it

BugLens runs locally at http://localhost:8000/app/playtest. Laya plays the game locally on an NVIDIA CUDA GPU. A separate API model writes the bug report from the recorded evidence. Tested on: Windows, Python 3.12, NVIDIA RTX 3070 Ti, PyTorch 2.6.0+cu124, Laya 0.3.21, Node.js/npm, Docker Desktop (Linux/WSL2). CUDA is required; there is no CPU fallback. 1. Install git clone https://github.com/yusif-v/NeuroBridge.git cd NeuroBridge py -3.12 -m venv .venv .venv\Scripts\python.exe -m pip install -r requirements.txt .venv\Scripts\python.exe -m pip install torch==2.6.0 --index-url https://download.pytorch.org/whl/cu124 .venv\Scripts\python.exe -m pip install laya==0.3.21 transformers==4.57.6 huggingface-hub==0.36.2 .venv\Scripts\python.exe -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='convaiinnovations/laya', allow_patterns=['multilingual/**'], local_dir='models/laya')" Copy-Item .env.example .env 2. Configure .env dotenv BUGLENS_SANDBOX_IMAGE=buglens-sandbox:local BUGLENS_LAYA_MODEL=./models/laya/multilingual AI_API_BASE_URL=https://themes-during-conflicts-terrorists.trycloudflare.com/v1 AI_API_KEY=YOUR_VALID_PROVIDER_KEY AI_MODEL=cx/gpt-6.1-sol(high) Replace the key with a valid key for this gateway. Without it, gameplay testing still works; only the AI report analysis is skipped. 3. Build the sandbox and UI (Docker Desktop must be running) docker build -t buglens-sandbox:local sandbox cd frontend; npm ci; npm run build; cd .. 4. Run (two terminals, from the repository root) .venv\Scripts\python.exe -m uvicorn backend.app.main:app --host 127.0.0.1 --port 8000 .venv\Scripts\python.exe -m backend.app.worker 5. Test. Open http://localhost:8000/app/playtest and upload a native Linux x86_64 game build ZIP. For the planted-bug demo, build the ZIP: .venv\Scripts\python.exe scripts/build_door_demo.py --godot C:\Tools\Godot_console.exe --runtime C:\Tools\Godot_linux.x86_64 Upload data/door-demo/DoorRuleBugDemo-Linux.zip, select "Key required for exit", set the budget to 10, and use this goal: ▎ Test the locked exit without collecting the golden key. E interacts with the door. Victory must require the key. A/D move, Space jumps, W/S climb. The result appears in Bug Reports with screenshots, the fresh-container replay and the AI analysis. Limitations: Linux builds only (Windows EXE through Wine is experimental). The report API uses a temporary Cloudflare URL that must stay online. There is no login system. A fresh checkout has no earlier runs. An inconclusive run does not mean bug-free. Full details: docs/BUILD_PLAYTEST.md, docs/AI_INTEGRATION.md.

Project ownership

The team keeps the rights to this project. Judges were given access for verification only.