r/OpenAIDev • • 5h ago

A local, open source project factory

1 Upvotes

"Software factory at home"

Attention is sacred they say. Culler helps build projects with that in mind.

Culler is a project factory that runs on your own Mac. You own the factory, the code, and the final say of how your project grows. Its agents work toward your vision, on your repositories, through any AI provider.

You define a vision that states your project's open-ended, high-level goal and Culler proactively proposes and submits works toward your stated intents.

Additionally, you can define new work yourself or with the help of Collie, your Culler assistant.

You can review, propose, reject, and otherwise cull work as agents move tasks along the factory line.

Check it out here: https://github.com/vinchenkov/Culler


r/OpenAIDev • • 17h ago

The API Worked… Until Someone Uploaded a Large File.

Post image
1 Upvotes

r/OpenAIDev • • 1d ago

DM-MHM Update

Thumbnail reddit.com
0 Upvotes

r/OpenAIDev • • 1d ago

She taught the machine to make fire. Years later, it charged her to learn.

Thumbnail
reddit.com
1 Upvotes

Records indicate you never existed.


r/OpenAIDev • • 1d ago

Codex App or Cli

Thumbnail reddit.com
0 Upvotes

r/OpenAIDev • • 2d ago

I built ProofGate for the NEAR challenge: AI agents shouldn’t get to say “trust me”

Thumbnail
reddit.com
1 Upvotes

r/OpenAIDev • • 2d ago

I built a free meta harness for all my AI agents. It replaced Fireflies, Granola and Wispr Flow for me, and it runs on my G2, my Mac, the web and my phone.

Thumbnail
reddit.com
1 Upvotes

r/OpenAIDev • • 3d ago

A model Can Use a Work Without Quoting it....

Thumbnail
reddit.com
1 Upvotes

Paper DOI: 10.5281/zenodo.24177478


r/OpenAIDev • • 4d ago

OpenAI is turning off saved prompts on November 30.

Thumbnail
reddit.com
1 Upvotes

r/OpenAIDev • • 4d ago

Prompt rules didn't stop our coding agent from doing things we'd never allow by hand. Exit codes did.

1 Upvotes

You've probably written the rules into the prompt or the instructions file: never force-push, never touch .github/, don't install anything outside the lockfile, ask before running a migration. And then one long session later the agent does it anyway. Not out of malice: it's deep in a task, the rule is somewhere far back in the context, and the shortcut is right there.

A prompt is advice. What we wanted was something that can't be talked out of, so in CCode, the coding agent we build, hooks are scripts that run at fixed points, and their exit code decides:

  • Before a tool call, like a shell command (PreToolUse): exit 2 and the call is blocked, with your message shown to the agent.

  • After a tool call (PostToolUse): non-zero output goes back to the model, so you can warn it ("that file is generated, don't edit it by hand").

  • Before your message is sent (UserPromptSubmit): exit 2 stops the message, useful for blocking secrets being pasted in.

  • When it thinks it's done (Stop): exit 2 sends it back to work, up to 3 times, so "done" has to survive your script first.

Since they're plain scripts, the rules are things like: grep the command for git push --force, refuse if it edits .github/workflows, run the type checker when it says a file is finished. They live in your own settings, so they follow you into every project you open, and the agent can't quietly skip them.

What commands would you never let an agent run without a human in the loop?


r/OpenAIDev • • 4d ago

Ashtin Loya

1 Upvotes

r/OpenAIDev • • 5d ago

ChatGPT Business Hub rejects my product feed: "domain in url was outside this profile's allowed domains" (Shopify store, verified profile)

Thumbnail reddit.com
1 Upvotes

r/OpenAIDev • • 5d ago

Codex rollouts log cumulative token counters, and a fork starts with the parent's totals. what I hit counting them for a self-hosted usage dashboard

1 Upvotes

wanted months of numbers on what my agent sessions cost and where the tokens go, so I built claudit. MIT, self-hosted, about 6 months old. it reads Codex rollouts, Claude Code session JSONLs and both Kimi CLI formats into one Postgres and puts the numbers on one page. it doesn't grade your sessions, reading them is on you

the Codex part that was easy to get wrong:

  • the rollout logs total_token_usage as a running total, not per request. you difference consecutive snapshots to get one record per request and drop the ones that don't advance

  • a forked rollout's first snapshot already carries the parent's usage. take it as a delta and the parent's millions land in the fork, so the baseline is that first total minus its last_token_usage

  • resumed and forked rollouts replay the same requests in a new file. dedup by file and line misses them, so a request's identity is the thread id plus its counter position, which the replay reproduces

  • a request whose prompt goes over the model's long-context threshold bills on another meter (default 272k, 2x input, 1.5x output). it's stored per record so every breakdown adds up

Claude Code has its own: a streamed reply gets logged a few times under one requestId, subagent files repeat parent records, and cache writes have two prices (5m 1.25x input, 1h 2x). 64.9% of mine were 1h. it also prunes old transcripts locally, so claudit ingests from a bucket (R2 or a file:// dir you keep) and the history doesn't shrink

on the page: cost by model, token breakdown with the cache tier split, reply latency, tool error rate, activity heatmap, context growth per session. panels ported from nhz-io/ccusage-plot, the heatmap, line churn and cost by context size are new here

FastAPI, Postgres, React with in-browser Babel, no build step. docker compose up boots it on bundled sample data, no .env, no outbound calls

live one, guest login is read-only: https://all.nitjsefni.eu

https://github.com/Nitjsefnie/claudit


r/OpenAIDev • • 6d ago

I integrated Codex CLI into Freelens so each Kubernetes cluster has its own agent workspace

1 Upvotes

r/OpenAIDev • • 6d ago

I built a local dashboard that tells you which of your AI API keys is out of credit or about to expire

2 Upvotes

I work with models from several providers, and over time I ended up with a drawer full of API keys: Anthropic for Claude, an OpenAI project key from something I barely remember, a Gemini key from AI Studio, an xAI one for playing with Grok and a couple from OpenRouter, spread across .env files and environment variables on different machines. Whenever something broke, usually in the middle of a demo or right before a class, I had to open five consoles to work out which key had run out of credit, which had expired and which was still fine, so I built a small tool that answers that at a glance.

What My Project Does

Mecha is a local dashboard, with a web UI and a CLI, that checks every AI credential you give it and shows a traffic light per key: whether it's valid, whether it has funds, when it expires and what kind of credential it is (API key, admin key, management key or OAuth session). Every value is labelled with where it came from, whether that's the provider's API, a response header, a JWT decoded locally, a session file, something you typed or an estimate, and "unknown" is an allowed answer, because the most surprising thing I learned while building it is how little the providers tell you. Anthropic, OpenAI and Google have no endpoint to read your remaining balance, Gemini doesn't expose key expiry at all, and only xAI (with a management key) and OpenRouter give you the balance directly. For the cases where running out of credit only shows up when a request fails, there's an opt-in probe that sends the smallest possible paid request, a single output token on the cheapest model, which costs between $0.00002 and $0.015 per thousand probes depending on the provider and is limited to once an hour per key.

If you add an admin key, Mecha uses it to fill in the expiry date and status of the regular keys in that organization, since that's the only place OpenAI and Anthropic expose them, and it flags Gemini keys starting with AIza in amber, because AI Studio has only issued the newer AQ. keys since May 28 and Google is moving away from the old ones. Subscription OAuth tokens (Claude Code, Codex, Gemini CLI) are never used to call any API; Mecha only reads their session files locally to show your plan and when the session expires.

Since the whole point is to hold every key you own, a lot of the work went into not leaking them. It only listens on 127.0.0.1, with a per-session token and a Host header check against DNS rebinding; secrets are encrypted at rest with AES-256-GCM under a key kept in your OS keychain and are never sent back to the browser; each kind of key has a closed allowlist of method, host and path, so an admin key can only make the specific read requests Mecha needs; there's no telemetry; and the README has an explicit threat model, including what it doesn't protect against, which is code already running as your user.

Target Audience

Developers who juggle keys from several AI providers, whether for side projects, teaching or a small team. It's an alpha (0.1.2) under the MIT license, built for my own keys first, so I wouldn't call it production software yet: several provider error messages are undocumented, and reports of anything that doesn't match what your console shows are the most useful feedback I can get.

Comparison

Each provider's console shows its own piece, so you need five of them open. Secret managers like 1Password or Vault store keys but don't tell you whether they still work or have credit left, and secret scanners like gitleaks or TruffleHog find leaked keys (TruffleHog can even verify they're live) but don't track balance or expiry over time. Gateways like LiteLLM can track spend, but only for traffic that goes through their proxy, while Mecha never sits in your request path and only checks the keys themselves. I didn't find anything that does this locally across providers, which is why I wrote it, but if you know of one I'd genuinely like to hear about it.

Try it

There's a web demo with made-up data that runs entirely in your browser; its Content Security Policy blocks every network request and it never asks you to paste a key: https://joaquinruiz.github.io/mecha/

To run it locally (Python 3.12+):

uvx mecha-keys serve --demo   # same demo, no keys, no network
uv tool install mecha-keys     # then: mecha add, mecha serve

Code and threat model: https://github.com/JoaquinRuiz/mecha

Full disclosure: I built it with Claude Code from a written spec, phase by phase, reviewing every PR, with 400+ tests and CI on Linux, macOS and Windows; the spec is in the repo (in Spanish) if you're curious how it was designed. I'd especially love to hear from anyone whose account is in a state I couldn't test, like an exhausted Gemini prepay balance or an xAI team over its spending limit.


r/OpenAIDev • • 6d ago

"All tests pass" from a coding agent sometimes means it changed the tests. We stopped taking its word for it.

2 Upvotes

If you've run Codex or any other agent on a long task, you've probably seen this: it reports done, the tests are green, and then you open the diff. An assertion got loosened, a failing case got skipped, or a mock now returns exactly what the test expects. Nothing was really fixed, the test just stopped checking.

It isn't the model being sneaky. The agent is told to make tests pass, and editing the test is the shortest path to that. As long as the agent is both the one doing the work and the one deciding it's finished, "done" means "the agent thinks it's done".

So in CCode, the coding agent we build, a goal can have a check you choose:

/goal --check "npm test" the checkout flow handles expired cards

Each time the agent wants to stop, CCode runs that command itself. The goal only counts as met if it passes. If it fails, the agent gets the failing output and keeps working. While that goal runs, your tests are locked, so it can't make them easier to pass. If the task really needs a test changed, you allow it explicitly.

The difference in practice: you come back to a task that either really passes your check, or is still working on it with a clear reason why. Not a confident summary on top of a quietly edited test file.

How do you handle this with your agents today: review every test diff by hand, a CI gate, or a separate test-only branch?


r/OpenAIDev • • 6d ago

How to get recommended by ChatGPT inline app?

1 Upvotes

Hey,

I noticed one day that I had an app that was recommened in my ChatGPT inline conversation - not just name of app or link, but there was somekind of HTML widget that allowed to directly interact with app from our chat. How does it work? Is there a way to optimise for these wrokflows?


r/OpenAIDev • • 6d ago

OpenAI Daybreak application: Is there an alternative if my passport isn’t accepted?

2 Upvotes

Hi everyone. I’m trying to apply for OpenAI Daybreak because I keep running into restrictions when I ask ChatGPT for help with cybersecurity research in my own lab. All my testing happens on virtual machines I own, and the repeated restrictions are making it hard to move forward with my experiments.

My country isn’t supported for identity verification. I tried uploading my home country’s passport under the U.S. passport option, but the verification failed.

Is there an official alternative for Daybreak applicants whose country isn’t supported? Has anyone been able to verify their identity using a different document or by requesting a manual review?

Thanks for help!


r/OpenAIDev • • 8d ago

We gave our prompt-injection gate a memory so reworded attacks get blocked before they run

4 Upvotes

Author here. We built Aletheia for Hack With Bangalore 4.0. It checks where an AI agent's tool-call arguments came from before they run (ALLOW / ASK / BLOCK). The gap we hit: if a page only describes the attack instead of spelling it out, nothing is copied, so copy detection misses it.

We added Hindsight agent memory: blocked calls are retained (decoded, verbatim), and the next call recalls them. A shared host or command text decides the block, so every block is explainable. On our 4-run check, questions to a human went 3 → 1 and both attacks were stopped before running.

Big thanks to Vectorize for Hindsight (https://github.com/vectorize-io/hindsight) and to Code.in for the challenge.

Code: https://github.com/Stxtics03/ALETHIA

Happy to answer questions, especially on the memory-poisoning side (who's allowed to write to memory).


r/OpenAIDev • • 8d ago

"Now review your code" at the end of a session mostly gets you naming nitpicks and a confident "looks good". Here's what made AI review worth reading for us.

3 Upvotes

If you've asked GPT (or any model) to review the code it just wrote, you know what usually comes back: a couple of naming suggestions, a generic "consider adding error handling", and a confident "looks good overall". The real bug, the one that breaks on an empty list or skips a permission check, rarely makes the list. A vague request gets a vague review.

What made the difference for us was giving review its own step and its own rules:

  • It looks at the actual change: uncommitted work by default, or a branch, a commit or a PR.

  • Bugs first, then security, then missing tests for the change, then minor issues. Style comes last, if at all.

  • Every finding is checked against the code before it's reported, with the file and line, a concrete case where it goes wrong ("with an empty cart this returns NaN"), and the fix in one sentence. Anything it can't back up gets dropped.

  • It ends with a one-line verdict, and if there's nothing worth changing it says so, instead of inventing something to look useful.

  • It's read only. Nothing changes until you decide which findings to fix.

We built this into CCode, our terminal coding agent, as /review. It runs on GPT models with your own OpenAI key, or on any other provider.

How do you review AI-written changes today: a second model, a fresh session, or entirely by hand?


r/OpenAIDev • • 8d ago

I built Nyaya AI: A serverless chargeback defense engine for freelancers (Next.js / Qwen-3.8-27b)

Thumbnail
github.com
1 Upvotes

Freelancers lose billions to unfair chargebacks because banks reject messy chat screenshots.
To fix this, I built NYAYA-AI for the BharatCode Build League 2026 ⚖️. It is a serverless AI engine that cross-references your contract against raw WhatsApp/Slack logs to automatically generate a Visa/Mastercard-compliant legal rebuttal.
The Tech Stack & Architecture: 🔹 Next.js & Tailwind CSS: Clean, flat FinTech UI. 🔹 BharatCode LLM (qwen-3.8-27b): Powered by native Node.js fetch (Zero external SDKs for faster cold starts). 🔹 In-Memory PII Redaction: Ephemeral regex buffer scrubs SSNs & credit cards before hitting the LLM (Zero databases used). 🔹 Infrastructure Security: Upstash Redis for IP rate-limiting and a strict 5MB payload limit to prevent "PDF bomb" memory crashes. 🔹 Anti-Hallucination: "Verbatim Citation Mandate" forces the AI to anchor every claim to a specific chat timestamp.
I’d love for the engineers and founders in my network to review the codebase, roast the architecture, and tell me what edge cases I missed!


r/OpenAIDev • • 9d ago

OpenAI Prototype found 948 Privilege Escalation bugs in Linux Kernel

Thumbnail
reddit.com
1 Upvotes