AFTER HOURS — Devpost About the Project
This is the copy-ready English story for the Devpost About the project field.
Inspiration
The project started with a command called make night. I ran it, it generated data, and the application displayed the results. Technically, it worked.
But I still could not answer a simple question: what did the AI actually learn?
A claim such as “the agents played 300 games” felt weak if I could not connect the score to a model decision, a behavioral change, and evidence that somebody else could inspect. I wanted to build an AI-learning demo where failure remained visible and the final discovery became something a person could try.
That frustration became AFTER HOURS.
What it does
AFTER HOURS is a single-screen browser game built around NEON GRAZE, a small deterministic arcade game.
Three AI players begin with different bounded policies. They play ten seeds across ten generations, producing:
3 players × 10 seeds × 10 generations = 300 verified replays
Eight seeds are used for training and two are held out for audit.
Between generations, GPT-5.6 Luna reads compact metrics and replay references, then proposes one bounded policy change for each player. The code validates the proposal, runs the next generation, and records what actually happened. The interface deliberately keeps GPT-5.6’s expected effect separate from the observed result.
After nine strategy-analysis stages, GPT-5.6 Luna performs one final culture-synthesis stage and turns recurring, evidence-backed behavior into a Technique.
The experience has three modes:
- WATCH AI LEARN — follow policy changes and verified replay evidence.
- RESULTS — inspect the learning curve, ranking, model provenance, and final Technique.
- CHALLENGE — attempt that Technique yourself on the same seed and game engine.
The Challenge independently checks the move pattern, combo requirement, and target score.
How I built it
The core is one deterministic TypeScript engine shared by AI simulation, replay verification, browser playback, and human play. Each replay stores its seed and legal actions, so the verifier can reconstruct the complete run and reject modified scores, combos, or summaries.
GPT-5.6 Luna is invoked through codex exec using my local Codex login. It does not control the game turn by turn. Its role is limited to interpreting verified behavior, proposing bounded policy mutations, and synthesizing the final Technique.
Each model stage uses structured JSON output, schema and semantic validation, a read-only sandbox, input/output hashes, token and latency records, replay references, and explicit fallback labels. The checked-in submission contains nine accepted strategy stages and one accepted culture stage.
I used Codex throughout development to implement and review the game engine, evolution runner, schemas, replay verifier, bilingual React interface, tests, and submission checks. Human decisions defined the evidence boundaries: deterministic replays, held-out audit seeds, bounded mutations, explicit fallbacks, and no per-turn GPT control.
Codex also created the submission video pipeline. It drives the real application with Playwright, runs the complete experience through a successful human Challenge, adds synchronized narration and captions, renders the MP4 with FFmpeg, and verifies the resulting video and audio properties.
Challenges I faced
The hardest problem was separating explanation from evidence. A model can produce a convincing reason for a policy change, but that does not prove the next generation improved. I had to keep the expected effect, observed effect, and replay evidence as separate records.
Another challenge was judge access. The generation pipeline uses my local Codex authentication, so it cannot be treated like a hosted API. I made the submitted experience run entirely from a checked-in, verified evidence bundle. Anyone can clone the repository, inspect the records, run the verifier, and play the challenge without an API key.
The interface was also difficult to simplify. The project contains simulations, mutations, audit seeds, replay provenance, a leaderboard, and a playable game. I reduced that to one screen and three clear actions so a judge can understand the loop without reading the architecture first.
Finally, not every accepted mutation improved the score. I kept neutral and negative outcomes visible because hiding them would make the learning story less credible.
What I learned
The most useful role for the model was not controlling every action. It was reading compact evidence and making a small, interpretable proposal that deterministic code could test.
I also learned that auditability can improve the product experience. Replay IDs, held-out seeds, and observed deltas started as engineering safeguards, but they became the story of the interface.
Most importantly, a human challenge communicates transfer better than another leaderboard. If the final behavior can become a move that somebody else can attempt, the AI’s discovery feels concrete.
Accomplishments I am proud of
- 300 deterministic, reconstructable replay records across ten generations.
- Eight training seeds and two held-out audit seeds per player and generation.
- 27 accepted bounded policy mutations.
- Ten verified GPT-5.6 Luna stages: nine strategy analyses and one culture synthesis.
- One game contract shared by simulation, verification, playback, and human play.
- A bilingual, single-screen experience that runs locally without an API key.
- 65 automated tests plus browser-level happy-path coverage.
- A public demo video generated by a reproducible Codex-authored pipeline.
What is next
I would like to generalize the evidence loop beyond one arcade game. A game designer could define a deterministic environment, bounded policy fields, evaluation metrics, and a human-transfer test. AFTER HOURS could then become a small laboratory for game balancing, agent evaluation, and explainable strategy discovery.
Links
Image gallery upload order
The five PNGs below are captured from the real English application at 1500 × 1000 (3:2). Each file is below Devpost’s 5 MB limit.
| Order | File | Suggested caption |
|---|---|---|
| 1 | docs/images/devpost/01-overview.png |
AFTER HOURS turns 300 deterministic simulations into a replayable ten-generation learning loop. |
| 2 | docs/images/devpost/02-gpt-policy-change.png |
GPT-5.6 Luna proposes a bounded policy mutation; expected and observed effects remain separate. |
| 3 | docs/images/devpost/03-results.png |
Learning curve, final ranking, Technique evidence, and 10/10 model provenance on one screen. |
| 4 | docs/images/devpost/04-challenge-brief.png |
The evidence-backed Technique becomes a playable human challenge on the same seed and engine. |
| 5 | docs/images/devpost/05-technique-transferred.png |
The Technique is transferred only after the human replay passes pattern, combo, and score checks. |
To regenerate the gallery from the checked-in application:
make devpost-gallery
Built With
- codex
- gpt
- llm
Log in or sign up for Devpost to join the conversation.