Submissions - Collaboration Challenge

[wary garden]

Submit here!

[weary idol]

Public GitHub repo: https://github.com/Porter12346/sap-library
README explaining:
• What you built
• How Codex was used
• How to run it
Screenshots/demo encouraged: https://sap-library.vercel.app/?version=current&page=1&pageSize=10&sort=created_at&order=desc&uiView=card
Remember: No API keys in your repo

Used codex 5.3 on xhigh to basically create the whole app

[gleaming talon]

looks cool

[weary idol]

ty

[weary idol]

used codex heavily to build another integrated app with it: https://github.com/robertley/SAP-Calculator

[coarse haven]

Challenge Entry

Project name
NMS Toolkit

What I built
I built a No Man's Sky toolkit and save editor with deep editing workflows, recovery utilities, and 3D preview capabilities.

How this was collaborative
The collaboration was between me, Claude, and Codex.
Claude and Codex handled the full technical execution: coding, reasoning, reverse engineering, debugging, implementation iteration, and validation loops. My role was direction control: gut-feel corrections, priority calls, accept/reject decisions, and final ownership.

Project age and timeline
Earliest tracked release in project records: 2026-02-12.
Earliest commit visible in this repository history: 2026-02-15.
Latest commit observed in this review: 2026-02-19.

That gives an active build window of about 7 days in current records, with the densest delivery between 2026-02-15 and 2026-02-19.

Major feats achieved

1. Broad multi-domain save editor coverage across core gameplay systems.
2. 3D corvette builder with game mesh rendering and extraction pipeline support. (tba)
3. Cross-save vault for moving ships, multitools, and companions between saves.
4. Constellation editing with practical path optimization using nearest-neighbor plus 2-opt.
5. Base management improvements: library workflows, sorting, and budget analytics.
6. Expanded discovery and expedition workflows, including backup/restore capabilities.
7. Packaging and dependency reliability improvements for smoother installs.
8. Rapid delivery with repeated review cycles closing in green test states.

How to run (release still building))

1. Clone the public repository.
2. Install with pip install -e ".[dev]".
3. Start with nmstoolkit, or run python3 -m nmstoolkit.app.

Submission notes
https://github.com/pljeroen/nmstoolkit

[frosty wind]

Submission – Collaboration Challenge

Project Name: QashqAI Collaborative Voice App
Author: sifollahaslani
GitHub Repository: https://github.com/sifollahaslani/qashqai-voice--mltilingual

Description:
A multilingual, culturally-inclusive AI collaboration tool designed to support endangered languages, digital inclusion and real-time cooperative workflows.
Built with Codex-assisted components and aligned with OpenAI ethical usage guidelines.

Thank you for reviewing my submission.

[boreal umbra]

can we get cash instead of api credits

[dry coral]

Project Name: Pair Studio
Author: me
GH Repo: https://github.com/malwaretestinginfo/openai-contest

Preview at: https://openai.rs-st.de or https://openai-contest.vercel.app/

Descrption: Pair Studio is a serverless, real-time collaboration app built with Next.js (App Router, TypeScript). It combines a synced Monaco code editor, a custom HTML5 canvas whiteboard, multi-user room collaboration (create/join/password), live code execution, and a streaming AI assistant via Groq. Realtime state is powered by Liveblocks, and room metadata is persisted in PostgreSQL for reliable cross-browser access and reloads. Codex was used end-to-end for architecture, implementation, debugging, and iterative UX improvements.

[distant sierra]

Do I have to use Codex specifically or can I use another agentic AI wrapper for OpenAI? (I prefer to use Warp as the interface layer but pretty much exclusively use OpenAI models with it)

[light junco]

Made this: https://github.com/mihir-s-05/agent-mailbox
It is a way for coding agents to communicate with each other. Works similar to SMTP except it pulls from the mailbox. It works between Codex and Claude Code and can scale as well. Built primarily using Codex, and obviously tested with Codex as well. Used 5.3 high for all of it.

[shell wharf]

Posted, for humans in the loopt 🤔. https://github.com/pablopoo/posted

[uncut lily]

Gaming is a valuable sandbox for collaborative development exploration because the state-space of a game is relatively mapped and finite compared to real life problems. The objectives pursued by the player in the game are intuitive to both the player and Codex.

https://github.com/tinycrops/assistant-poe

[sly furnace]

Interesting to see how the gaming/ modding community is utilising codex 👏🏻

[indigo rune]

@lethal belfry plzz lauch cybersec challenge or ctfs codex is not god in ctfs

[obtuse dust]

https://github.com/raj77in/autonomous-agent-ctf -public repo link

[quaint dome]

I’ve been experimenting with structured multi-agent orchestration for tasks and built something I call CodeBoard.

It’s a local-first workspace for task-scoped discussions using a Lead / Helper collaboration model, persistent round artifacts, and explicit phase orchestration.

The goal isn’t “more agents”.
It’s predictable reasoning quality.

What I tested:
1) Hard reasoning (Collatz conjecture)
Structured proposals → synthesis → open discussion → final draft with confidence.
Not about solving it — about stress-testing reasoning structure.

2) Simple logic trap (Car wash question)
A deceptively easy question many single agents overcomplicate.
With orchestration, the system stays stable and produces a clean decision.

And many other tests, now you can experiment yourself. 🙂

Why it matters:

• Role-separated reasoning (Lead vs Helpers)
• Explicit round phases
• Persistent task context
• Works with OpenAI / Codex, local Qwen, OpenAI-compatible endpoints
• Local-first (Prisma + SQLite)

I’m testing whether structured orchestration actually improves reasoning stability and reduces logical drift, instead of just adding architectural noise.

CodeBoard codebase was written with codex.
Delivery timeline:

• initial implementation: GPT-5.3-Codex
• multi-iteration middle phase: GPT-5.3-Codex-Spark
• final code polish and stabilization: GPT-5.3-Codex

There are many ideas for expanding this further, but my resources are limited, so development is iterative and focused.

Built as an experiment. Evolving carefully. Feedback appreciated.

https://github.com/1dZb1/CodeBoard

[indigo grail]

https://vsolitaire.com
Online solitaire with VS mode and rooms

[low epoch]

I created in cooperation with codex 5.3, Sonnet 4.6 and opus 4. 6 a vision encoder, that hits my Projekt needs.

Codex made the Main part, inclusive helping me setting up the github account.

Sonnet did cross over review and made some parts of documentation and encoder framing.

Opus made gausse mathematics and cooperative with codex some code part. It was fun to creating this.

I share a screenshot from phase m1 that shows how we worked together.

For communication, we used one md file DEV_NOTES_M1 to M4 for each milestone. This was our shared asynchronous memory.

https://github.com/soenning-ai/fnvision

[low epoch]

Update:
I prepared a new NN for this encoder and trained it. I share observer Screenshots where you can see that i save around 85%

For training and testing i used YouTube Videos via Firefox (click play and let watch) 😬

[sly furnace]

I built ScenarioForge, a collaboration-first QA app where PM/QA/dev teams and Codex work from the same source of truth.

Creating tests is hard and abstract, especially for vibe coders.
What started as a simple skills.md experiment turned into this whole idea: how to actually use Codex app-server as a collaborative scenario engine.

I won’t pretend it was easy. I spent way too much time on it, got stuck a lot, and still don’t fully understand every edge case. But I learned a ton. The biggest mindset shift was moving away from fully deterministic coding and learning how to design flows where AI can make bounded decisions using primitive tools, while still keeping auditability and guardrails.

In short, ScenarioForge works like this:

• Sign in with ChatGPT
• Connect/auth your GitHub repo
• Pick a repo/branch
• Run the source trust gate
• ScenarioForge uses your docs (markdown/json/etc) plus actual app logic to generate user-centric scenarios
• It outputs both markdown and JSON artifacts you can download
• Then you can run the execute loop, which iterates scenario by scenario, captures observed vs expected evidence, attempts fixes, reruns impacted scenarios, and if ready, prepares PR/branch outcomes

It’s definitely not perfect yet and still needs fine tuning, but I wanted to push this approach and see what’s possible when Codex is part of the collaboration loop, not just a code autocomplete tool.

How to run:
pnpm install
pnpm dev
app: http://localhost:5173

Setup details and env vars are in the README.
No API keys are committed.

Screenshots attached:

Source trust gate
Generation stream
Execute board
Completed evidence view
Dashboard telemetry

Repo: https://github.com/georgestander/scenarioForge

[pearl stag]

I built Discodex, which turns OpenAI Codex into a collaborative, multiplayer coding experience inside Discord.

Instead of each developer running Codex alone in their terminal, the entire team can share AI coding sessions in Discord threads — visible, interactive, and persistent — just like the Codex app, but in multiplayer mode.

Some Features

• Multiplayer by design — Multiple team members can prompt, refine, and review within the same thread. Great for pair prompting, handoffs, and team learning.
• Flexible subscription usage — In addition to shared sessions, each Discord user can use their own Codex subscription. Discodex supports multi-user setups via CODEX_HOME switching while sharing sessions through symlinks.
• Granular access control — Admin and user roles with nine capability toggles. Control who can chat, change settings, or confirm actions.
• Real-time progress tracking — Live status updates show what Codex is doing, with full logs attached upon completion.

Quick start (Docker)

git clone https://github.com/JacobLinCool/discodex && cd discodex
echo "DISCORD_TOKEN=your-bot-token" > .env
docker compose up --build -d

Then invite the bot to your server, run /init, and start coding in threads!

If you already have Codex authenticated on your host, add the following to .env to skip in-bot authentication:

DISCODEX_USE_SYSTEM_CODEX_HOME=true

Then mount your Codex home directory by adding:

- ~/.codex:/root/.codex

under volumes in docker-compose.yaml.
Otherwise, simply run /auth login in Discord after starting the bot.

⚠️ Security note:
Only assign the discodex-user role to people you trust. The bot runs Codex with real credentials and file system access — treat it as granting someone SSH access to your development server.

https://github.com/JacobLinCool/discodex

[amber mural]

We're excited to submit Viarah! to the OpenAI developer challenge. Viarah! Is a collaborative Project delivery application where PM's, engineers, and clients realize their ambitions. Via the companion viarah-cli, the entire application can be controlled via natural langauge, meaning, codex!

How Codex was used?
The entire Viarah! application was first researched, then scoped and planned into milestones and issues, and finally autonomously built over a period of several days of non-stop coding sessions. Exclusively built by GPT 5.2 Xhigh inside of Codex CLI, via multi-agent orchestration workflows that carefefully triage, resolve, review, test, and release. The longest uninterrupted single coding session lasted over 9 hours and 20 minutes. Issues are included in the public repo that capture the entire process for those interested.

Humans were in the loop after the first MVP build finished to iterate with codex on predominately front-end improvements and some enhancements to Viarah!'s initial set of features.

At the time of writing, Viarah! is undergoing internal testing and will receive some additional updates before being production-ready in the coming days or weeks. Viarah! is designed to be operated by Codex first, as our PM's and engineers will use natural language to perform operations like "create a new report with team availability over the holidays with a calendar and list view" or "I'm available for 3 extra hours on Saturday", or "Update the client that the dashboard preview is ready", etc. A handful of human interfaces therefore, will benefit from, and see a number of UX and quality of life improvements in the coming days.

We hope you enjoy Viarah! and if you want to drop us a line, please find us at [e-mail] and via-logos.com.

Enjoy!

https://github.com/vialogos/viarah

[lyric basin]

Taskery

Taskery is a local-first Kanban task board built for humans and AI to use at the same time. It has three interfaces that all hit the same backend:

• A drag-and-drop web board
• A REST API
• CLI that outputs JSON

The idea is simple: you move cards around in the browser while Codex creates, updates, and triages tasks through the CLI, and everything stays in sync.

Features:

• Task Management
• Customizable Notifications
• Kanban Board
• PENDING | STARTED | BLOCKED | REVIEW | COMPLETE event stages
• GUI and CLI interfaces
• Custom Color Themes

How it was built

The whole thing was built using Spark subagents (with Codex 5.3 high as orchestrator) to handle implementation across the monorepo.

You can connect this Kanban Task manager to any coding agent and it can manage tasks, you can even parse plans and have the agent work through a plan, like beads.

https://github.com/am-will/taskery

[lyric basin]

Better demo here

[restive oyster]

How often are these challenges created? I'd like to attempt to participate in the next one!

[near kestrel]

StatRumble

StatRumble is a prototype of a collaboration-first, metric-driven debate app where teams debate a selected chart range, generate an AI referee report, and promote it into a shareable decision page.

It explores how Codex-powered, structured data transformations can support smoother analysis and iteration.

Problem: metric debates often stall because people argue over different time windows and don’t leave behind reusable decision artifacts.
StatRumble keeps the workflow consistent and demoable: range → discussion → judgment → decision.

AI/Codex usage: Built with ChatGPT + Codex across architecture, implementation, refactors, and polish.

Transform proposals: generate safe transformation specs (and previews) to propose/fork/review time-series changes.

Diff summaries: summarize parent/child proposal changes for quick review.

Referee/Judge: produce a thread-level report + outcome (stored and promotable).

Outputs: arena threads (discussion/votes) + referee reports/outcomes; public decision pages.

Guardrails: narrow scope for reliable end-to-end demos; no keys committed (.env.local); demo mode by default.

Roadmap: more data formats/metadata beyond CSV time-series; richer Codex-assisted transforms/analyses and visualizations; stronger collaboration basics and a more visualization-centered, discussion-friendly UX.

Repo: https://github.com/Aurna-code/statrumble