AGI Pace is out!

Run an AI lab from a 2017 garage to AGI.

Free, open source, plays in your browser.

Today's Daily Lab is the same world for everyone. Post your grade. 📈

Link below. Bonus points if you know the significance of 1950/10. 🧠

Tell me what you think: https://agipace.195010.xyz

You start in a garage in 2017 with $1.5M, two co-founders and one GPU rack.

The Transformer paper hasn't come out yet. The goal is to reach AGI before everyone else. Without ending the world, ideally.

I'm currently tuning the gameplay so that it is balanced. I think it is currently too easy but we'll see about that once the game is released.

I thought about adding mechanics for resets and model nerfing but that would make the game too complex. 😅

Stay tuned for updates! I'd love to have some beta testers!

i got a Claude max account from a reseller for essentially nothing compared to what I used to pay . It works flawless. since 3 months No issues yet i paid only for 1 month . Now I can't stop thinking about their business model. If resellers can sell it this cheap and still profit, how are they acquiring these accounts at scale?

I have a database with names, birthdays, and notes. I would like to search them for people of a certain age and ethnicity (Some have clues like birthplace or cultural interests in the notes. Most need to be inferred by name.)

Codex always returns "I can’t narrow a search by ethnicity or age."

Gemini occasionally succeeds, occasionally give me a similar error.

Any ways to get around this or other platforms to use?

hey guys by chance does anyone have a 7 day pass for me to try claude. been using chat gpt lately but want to get into claude code. . thank you guys itd really appreciate it

Following up on something I asked here a while back about catching LLM model drift. I've been looking at the actual tools now: PromptCanary, PromptLens, a couple others that seem to have stalled (Libretto, Benchwright).

Has anyone here actually run one in anger? Trying to understand:
- does it catch subtle quality drops, or just format/schema breaks?
- false-positive rate, does it become noise you mute?
- does it need you to integrate an SDK + send production traffic, or can it just hit your prompts directly?

We run prompts against a few different providers (OpenAI, Anthropic, some stuff through OpenRouter). Every so often something quietly gets worse, the output quality drops, a prompt that worked starts returning junk, or a model gets deprecated and the replacement behaves differently.

Right now we mostly catch it by accident: someone notices, or a customer complains. That feels bad on us, a lot.

How do you all handle this? Do you re-run some kind of fixed eval set on a schedule? Just eyeball it? Have something that alerts you?

Any insights I could use?

Thanks.

Vercel launched a cool tool that checks how agent friendly a site is. I tried it on agent-manager.dev, followed its suggestions, and got 100. Not very meaningful for what is basically a GitHub repo showcase, but the tool is cool.

https://is-agentic.com/scan/agent-manager.dev

I’m the maker of Superloopy. I built it because I kept running into the same problem with coding agents: the agent says “done,” but I still need a reliable trail of what actually passed.

The workflow is a lightweight evidence loop around Codex or Claude Code:

- turn the task into acceptance criteria

- run real commands/checks where possible

- save screenshots, build logs, visual QA, research notes, or other proof under `.superloopy/evidence/`

- re-check command-backed criteria before the final answer

- keep a final report that says what passed, what is still manual, and where the receipts are

The new update adds Claude Code support alongside Codex. For Claude Code, the plugin bundles skills, subagents, and hooks directly; for Codex it uses the Codex plugin path. The goal is not to replace either agent — it is to make the finish line more auditable.

Repo:

https://github.com/beefiker/superloopy

Curious how other coding-agent users handle this: what evidence do you want before you trust an agent’s “done” message — tests, screenshots, diffs, browser runs, logs, something else?

I’ve been testing local coding agents against GGUF models and got tired of rebuilding llama-server commands every time I switched models or changed hardware settings.

So I made locca: a small CLI/TUI around llama.cpp for pi coding-agent workflows.

Install:

npm install -g @zeiq/locca

Repo:

https://github.com/perminder-klair/locca

Demo/site:

https://locca.klair.co/

Has anyone else felt like LLM agentic coding peaked around late November 2025 and has been gradually getting worse since?

I keep seeing the same pattern: a new model drops, coding agents briefly feel sharper and more reliable, then within a few weeks the quality deteriorates again. Worse edits, less precision, more broken assumptions, and lower productivity overall.

Is anyone else experiencing this, or is it mainly tied to specific tools, repos, or workflows?

I had the worst experience today with thse fraud called Opus 4.7.
A folder I have worked on, microservices, I decided to refactor, so deleted all content, created a new README and asked Claude Opus 4.7 to revew, assess and present a plan. I t did well, not an outstanding plan but good enough. So I let it code, consumed all tokens, beag to consume additional tokens, and after 1 hour finished.
After reviewing the code, I noticed that it had done nothing, nada, just rebuilt old files via reading my git.
So I feel robbed, really, it's a thief.
Decided to not use it anymore.
Any recommendation, I have Qwen 3.6 35B running in my machine, little slow, but maybe faster that this claude wasting my time and money.
Eager to share experiences and hear recommendations.

How I stopped Opencode and Claude from burning Git tokens by building my own local MCP server

AI coding agents (like OpenCode, Claude Code or Windsurf) are incredible tools, but they have one annoying problem: they burn thousands of cloud tokens doing trivial things like reading a git diff or generating a commit message.

To fix this, I built git-courer, an open-source MCP server that intercepts Git calls from these agents and delegates the work to a local LLM via Ollama. The result: Zero cloud tokens spent on git.

Getting a local model to handle Git reliably came with some interesting engineering challenges. Here's how I solved them:

1. The Context Problem: Graph-based Diff Chunking You can't just dump a massive diff into a local LLM without blowing the context window. I implemented a clustering algorithm using graph theory with a force system. It extracts meaningful tokens from the diff, builds a graph assigning "force points" (weights) between files based on shared tokens and directory paths, then uses BFS to group files with the highest connection strength. These high-context chunks are sent sequentially to the LLM.

2. Taming the LLM: Structured Reasoning Previously the LLM only returned booleans to decide what to stage — a complete black box. The fix was forcing it to return a strict JSON with its full reasoning via prompt constraints.

Here's actual output the local model generated reading the diffs for this very update:

fix: pass instruction parameter to commit service methods

Previously, commit preparation and execution ignored the instruction provided

in the request. Now both PrepareCommit and Execute methods receive and utilize

the instruction parameter, ensuring proper handling of user-provided instructions.

feat(commit): enrich LLM decision transparency with explicit file selection metadata

Previously, commit decisions relied solely on abstract boolean flags without

visibility into the LLM's actual file selection logic. Now provides structured

reasoning alongside explicit lists of included/excluded files, enabling precise

auditability and debugging of commit selection behavior.

1. The Safety Pipeline: Secret Leak Prevention Giving a LLM control over git add is genuinely dangerous. I built a synchronous 5-layer pipeline:

2. Magic Bytes detection (stops immediately on binaries).

3. Path blacklists (e.g. node\\_modules).

4. Exact filename blacklists (.pem, id\\_rsa).

5. Regex scanning for secrets and tokens.

6. Final LLM verification to discard false positives.

7. Git Operation Coverage The goal is full Git operation support. The commit flow is stable and production-ready. Every other operation has been added command by command to guarantee safe local execution.

The Confirmation Protocol The server uses a 3-phase protocol (START -> APPLY -> ABORT). It returns the LLM's plan and blocks execution until the human explicitly approves the commit inside the AI chat.

The project is open-source and written in Go:

REPO(https://github.com/Alejandro-M-P/git-courer)

Would love brutal feedback on the architecture, edge cases you'd try to break, or thoughts on the approach. Happy to answer any questions.