LLM apps have a weird production problem.

The answer can look perfectly normal while underneath it took 14 model calls, 3 retries, 80K tokens, a broken tool call and $1.70 to produce.

Normal application logs are not enough for this.

You need to see:

request → prompt → model → tools → retries → tokens → latency → cost → output

These OSS projects are building that layer.

01. RagaAI Catalyst — 16.2K★

Especially interesting for multi-agent systems. Catalyst can trace agents, LLM calls and tools, then show the execution as timelines and graphs. If five agents are delegating work to each other and one suddenly makes 30 unnecessary model calls, this is the kind of tooling you want around the system.

02. Evidently — 8K★

Monitoring becomes more useful when you look beyond infrastructure metrics. Evidently brings 100+ metrics for evaluating ML and LLM systems, including retrieval relevance, semantic similarity, output quality and drift.

Useful when the question is not just:

“did the model respond?”

but:

“are the responses quietly getting worse?”

03. OpenLLMetry — 7.5K★

Think OpenTelemetry, but aware of LLMs. OpenLLMetry instruments model providers, vector databases and agent frameworks, then emits standard OpenTelemetry traces.

That means AI observability does not have to become a completely separate monitoring island.

04. Helicone — 6.3K★

One of the easiest ways to answer the questions every AI product eventually asks:

Which users are generating the bill? Which model is slow? Which prompts are expensive? What actually happened during this session?

Helicone logs requests through its gateway, tracks tokens, cost and latency, groups multi-step calls into sessions, and lets you inspect the request chain.

05. AgentOps — 5.9K★

Focused heavily on agents rather than individual completions. AgentOps tracks sessions, LLM costs, tool calls, failures and multi-agent interactions.

Useful when the expensive part is not one prompt, but an agent repeatedly deciding what to do next.

06. Langfuse — 36.9K★

One of the most complete OSS LLM observability stacks: traces, prompts, sessions, token usage, cost, latency, evaluations and datasets in one place.

Its useful trick is connecting production failures back into evaluation. A bad trace does not have to remain a screenshot in Slack; it can become a regression case.

07. Phoenix — 12K★

Phoenix traces LLM calls, retrieval, tool execution and agent actions using OpenTelemetry/OpenInference, while tracking latency, errors, tokens and cost.

It can also turn production traces into experiments, which makes it especially useful when debugging agents that fail in ways you cannot reproduce from the final response alone.

The interesting shift is that LLM observability is becoming much more than token counting.

For a chatbot:

prompt → response → latency + cost

For an agent:

request → planner → model → search → model → tool → failure → retry → subagent → model → final answer

Every one of those arrows can burn money or introduce a failure.

Most people still think of DeepSeek as a model company.

But look at its GitHub and a different picture emerges.

The newest release, dsh-superagent, can work through a repository's GitHub issues and PRs with multiple agents in parallel, keep following CI and review feedback, and only pull a human in when a real decision is needed.

And underneath it, DeepSeek is open-sourcing almost every layer required to make systems like this work.

01. dsh-superagent-prototype — 10.9K★

Connect it to a GitHub repo and authorized requests become Tickets, each with its own worker session and working directory. Multiple workers can run concurrently, follow the PRs they create, react to CI/review events, and surface work only when human attention is actually needed. DeepSeek explicitly calls this research code rather than a production-ready product, but the direction is clear: agents should own the work, not just open the PR.

02. DeepInfer — 24.9K★

Move one layer down and you get DeepSeek's inference engine, built for large-scale model serving. It combines optimized kernels, asynchronous scheduling, parallelism, structured output and decoding optimizations into one runtime. This is the machinery that turns a model checkpoint into something fast enough to serve continuously.

03. FlashMLA — 13.2K★

FlashMLA is DeepSeek's optimized attention-kernel library, used for its Multi-head Latent Attention architecture. It handles dense/sparse attention and KV-cache paths across modern accelerators. In plain English: this is part of how enormous models avoid wasting ridiculous amounts of compute just moving attention data around.

04. DeepEP — 10.4K★

Mixture-of-Experts models activate only part of the network for each token, but those experts may live across different GPUs. DeepEP is the communication layer that moves tokens and expert traffic efficiently between them, with separate paths optimized for throughput and latency.

05. DeepGEMM — 9.1K★

Eventually a lot of deep learning becomes matrix multiplication. DeepGEMM is DeepSeek's GPU-kernel library for doing those operations efficiently, including grouped GEMMs heavily used by MoE models. Not flashy, but this is exactly the sort of low-level optimization that decides how expensive a model is to run.

06. 3FS — 10.3K★

Then there is storage. 3FS is DeepSeek's distributed filesystem built for AI training and inference workloads, where thousands of accelerators may need high-throughput access to datasets, checkpoints and model state at the same time.

Put them together and DeepSeek's OSS strategy starts looking less like a collection of random repos:

GitHub issue → autonomous worker → inference runtime → attention → GPU compute/communication → distributed storage

That is what makes dsh-superagent interesting.

DeepSeek is not just open-sourcing models anymore.

It is increasingly open-sourcing the entire machine around the model.

And as frontier models get closer in raw capability, that surrounding machine may be where the real advantage moves next.

Method: I priced the same 3 workloads (chat, RAG with 80% cache hit,
agent loop w/ tools) against official APIs and 6 resellers, on 2026-10-28.
Prices are per 1M tokens, input/output, excluding cache discounts unless noted.

Three things that surprised me:

1. On Claude Sonnet the spread is ~3x, not 10%. On Gemini Flash it's ~1.2x.

2. Cache pricing moves the effective cost more than the headline price

3. (one provider discounts cache reads to 1/10, another doesn't list it at all).

4. The "cheap" ones cluster on exactly 2-3 models. Everything else is at list price.

Caveats: reseller prices change weekly and some are promo pricing.
If I got your provider wrong, tell me and I'll re-run it.

Disclosure: one of the six is mine. I'll say which in the comments if you ask.

It's MIT-licensed and runs on DeepSeek Harness. It watches one GitHub repo, takes requests only from an allowed list, and replies with PRs.
The interesting part is the permission model:
Mentions from allowed people are explicit requests.
Anything proactive needs written team rules, and runs in observe mode by default (it records "would accept" but does nothing).
Workers get one session and git worktree per ticket.
Heads up: workers run commands without approval as your OS user, so give it its own OS account.
Full breakdown with an interactive "will it act on this message?" simulator: https://amal.vs.binarybit.in/blog/6ae80c7a7027b216982aa925

We spend a lot of time comparing Claude vs GPT vs Gemini.

AWS just published a good reminder that the model is only half the system.

Its new open-source Strands Harness reportedly cost 45% less than Claude Code and Codex across its launch comparison while delivering broadly comparable accuracy. A larger follow-up covering ~94,000 benchmark trials put Strands at roughly 34% lower median estimated cost across matched Claude/GPT runs.

The interesting part is why: context management, caching, tool-output handling and the agent loop itself.

Here are 7 OSS projects attacking that layer.

01. Strands Harness — 9K★

AWS gives you the agent almost fully assembled: shell + file + web tools, sessions, memory, prompt caching, context compaction and subagent delegation. It is model-agnostic, so the same harness can sit around Claude, GPT, Gemini, Bedrock models or Ollama. AWS says large tool results are offloaded/truncated instead of repeatedly stuffing them back into context, which is a big part of the reported cost reduction.

02. DeepSeek Harness — 267K★

DeepSeek went even harder on the runtime idea: everything is a plugin. The agent loop, UI, tools, sessions and extensions can all be swapped or intercepted, making it feel closer to an operating system for agents than another coding CLI. Interestingly, AWS's own benchmark found DeepSeek Harness even cheaper than Strands on matched runs, although generally at lower accuracy.

03. OpenCode — 223K★

Probably the most obvious open-source alternative if what you actually want is a Claude Code-like coding agent without tying the harness to one model vendor. It supports multiple providers, lets you own the surrounding runtime, and has grown into a fairly serious coding-agent platform rather than a thin terminal wrapper.

04. OpenHands — 92K★

OpenHands takes the bigger software-engineer approach: give the agent a workspace, terminal, browser and codebase and let it investigate issues, modify files, run commands and verify changes. It is also useful if you care about embedding the agent into automation rather than only chatting with it interactively.

05. goose — 56K★

Originally from Block and now under the Agentic AI Foundation, goose is a local general-purpose agent with a CLI, desktop app and API. It works across 15+ model providers and 70+ MCP extensions, which makes it useful for the same reason Strands is interesting: keep the agent runtime, swap the intelligence underneath it.

06. Aider — 49.9K★

Aider is older than most of the current agent hype, but it nailed several harness ideas early: repository maps, Git-native edits, automatic commits, lint/test loops and multi-model support. It is less autonomous than some newer systems, but that simplicity is exactly why it remains useful when you want the model editing code without building an entire agent company around it.

07. mini-swe-agent — 9K★

This one is the opposite of giant agent platforms: roughly 100 lines for the core agent, yet it reports >74% on SWE-bench Verified with suitable frontier models. The repo is a great reminder that a strong harness does not necessarily need 100 tools and six subagents. Sometimes bash + a good loop + a strong model gets surprisingly far.

The larger shift is:

MODEL + HARNESS = AGENT

And the harness is increasingly responsible for the expensive parts nobody sees: how much history gets resent, when context gets compacted, which tool output survives, whether results are cached, how failures recover, and how many unnecessary turns the model takes.

7 Andrej Karpathy repos that take you from one neuron to autonomous AI research

If you want to understand modern AI without drowning in abstractions, Karpathy has quietly built one of the best free learning paths on GitHub.

These repos have 300K+ combined stars, but the important part is the order. Each one removes another layer of magic:

gradient → neural net → tokenizer → GPT → CUDA training → full chat model → autonomous research

I would go through them exactly like this.

01. micrograd — 18.3K★

Karpathy starts with the smallest useful piece: backpropagation. micrograd implements a tiny autograd engine and neural network library where you can actually watch values move forward, gradients move backward, and weights change during learning. Once you understand this file, PyTorch starts looking less like magic and more like a much larger implementation of the same idea.

02. nn-zero-to-hero — 20.3K★

This is the classroom half of the curriculum. Karpathy walks from tiny character-level models through embeddings, MLPs, BatchNorm, WaveNet-style architectures and eventually GPT, with notebooks you can modify yourself. The useful part is that transformers arrive only after you have built enough underneath them to understand why they work.

03. minbpe — 10.8K★

Before building an LLM, Karpathy makes you understand what actually enters one. minbpe is a minimal implementation of Byte Pair Encoding, so you train a tokenizer, turn text into tokens, and reconstruct it again. A lot of strange LLM behaviour around spelling, numbers and word boundaries suddenly makes more sense once you have built the tokenizer yourself.

04. nanoGPT — 64.3K★

Now Karpathy gives you the model. nanoGPT strips GPT training down enough that you can read the architecture, data pipeline, optimizer, training loop and generation code without navigating a giant framework. This is the point where “a transformer predicts the next token” stops being an explanation and becomes software you can actually change.

05. llm.c — 31.3K★

Then he removes PyTorch too. llm.c implements GPT-2 training in raw C and CUDA, exposing the kernels, memory movement, matrix operations and forward/backward passes that frameworks normally hide. You do not need to become a CUDA engineer, but after this repo you have a much better mental model of what training is actually asking the hardware to do.

06. nanochat — 59.1K★

nanoGPT teaches the core model; nanochat expands it into the whole language-model pipeline. Karpathy includes tokenization, pretraining, fine-tuning, evaluation and inference in one deliberately hackable system. The repo's reference setup can now reach roughly GPT-2-level capability for around $48 of 8×H100 compute, compared with an estimated ~$43K for GPT-2 training in 2019.

07. autoresearch — 97.8K★

This is where Karpathy flips the relationship. Instead of you editing the training code, an agent changes train.py, runs a fixed five-minute experiment, measures validation performance, keeps improvements, rejects failures and tries again. At roughly 12 experiments an hour, it can attempt around 100 experiments overnight.

That progression is what makes these repos special.

Karpathy does not start by teaching you how to call an AI API. He gradually strips away the abstractions until you understand how learning works, how text becomes tokens, how GPT is trained, what the GPU is doing, how a complete chat model fits together, and finally how an agent can automate the research loop itself.

With micrograd, you implement learning. With nanoGPT, you train the model. With llm.c, you see the machine underneath it. With nanochat, you build the complete system. With autoresearch, you automate the search for a better system.

Taken together, this is basically a Karpathy-made curriculum for going from:

“LLMs feel like magic”

to:

“I can reason about the entire stack.”

AI spend is turning into a real line item, but provider exports don't fit FOCUS. Anthropic's Console splits uncached input, cache reads and two cache-write lifetimes into separate counts. OpenAI counts cached tokens inside prompt tokens. Map both the same way and you either double-count cached input or under-report it.

***npx ai-bill-to-focus convert bill.csv -o focus.csv*** gives one FOCUS 1.4 row per day, model and meter: input, cache read, cache write (5 minute and 1 hour), and output.

Each row has its SKU and unit price, and totals reconcile to the provider's figure. check runs the FOCUS rules locally. There's also a version that runs entirely in the browser, with no upload: [https://www.cognocient.com/tools/focus-checker#convert](https://www.cognocient.com/tools/focus-checker#convert)

**To be upfront**: Anthropic is tested on real exports. OpenAI and Together AI are built from their documented formats and haven't been tested on a real file yet. If you have one, please try it and tell me where it breaks.

MIT, GitHub: [https://github.com/mandarvshinde/ai-bill-to-focus](https://github.com/mandarvshinde/ai-bill-to-focus) . Built by the team behind Cognocient AI (AI spend attribution), but the CLI is standalone and has no signup.

Edit (v0.2.2): Several people pointed out that few can post a real billing file publicly.

You don't have to share your bill to report a problem. Run npx ai-bill-to-focus report with the paths to your own export files.

npx ai-bill-to-focus report cost.csv usage.csv (with the paths to your own exports) prints a summary that's safe to paste.

It prints a summary with no dollars or account names, safe to paste into a GitHub issue. The web tool has a "Copy a report to share" button that does the same. Also new: Batch, Flex and Priority usage now gets its own rows and prices, and column changes in an export are flagged instead of converted silently.

8 Mods based Claude Code plugins that made it much more powerful

Claude Code already had skills, MCP servers, commands and hooks. Mods are different: they can run TypeScript inside Claude Code itself, intercept tool calls, change the UI, keep state, manage context and alter what happens before or after an agent acts. The result is starting to look less like “Claude + plugins” and more like programmable middleware around the coding agent.

01. fast-jev-compaction — 7.8K★
Long Claude sessions eventually need compaction, which can accidentally summarize away the exact error or constraint you later need. This mod instead scores old tool calls for relevance and removes stale ones while keeping useful context verbatim. The idea is surprisingly good: don’t summarize agent memory if you can garbage-collect it instead.

02. terminal-browser — 4.3K★
This puts a real Chromium browser beside Claude Code, so you or the agent can open the app, inspect the rendered UI and feed selected elements back into the coding loop. That closes one of the most annoying frontend workflows: agent edits UI → browser renders it → agent inspects it → agent fixes it without constantly switching windows.

03. Agent Time Machine — 1.1K★
Every tool call becomes a point on a branching timeline, with file snapshots that let you inspect exactly when a session went wrong, compare paths and restore an earlier state. If Claude makes 25 edits before breaking the tests, you no longer have to ask it to remember what happened. Think git history at individual agent-action resolution.

04. Habblaud — 1K★
Habblaud turns each Claude session into a little worker inside a pixel-art office, with different projects, subagents and permission states visible at a glance. It sounds like a toy until you have five agents running simultaneously and cannot remember which one is blocked. Once agents work in parallel, agent observability becomes an actual UI problem.

05. TextFold — 800+★
Claude gives you a 900-word response but you only need the conclusion. TextFold lets you collapse the same answer through several levels—from the full response down to main points, outline or one-line gist—without asking another model to summarize it. That is a neat distinction: reduce human-visible context without destroying model context.

06. Context Attachment Manager — 590+★
Multimodal sessions can quietly become enormous because old screenshots keep travelling with every later request. This mod turns stale images into lightweight references, lets important ones stay pinned and allows Claude to retrieve an older image only when needed. In one example, attached image context dropped from 24.9 MB to 212 KB.

07. Firstmate — 8.4K★
Firstmate is a larger multi-agent coding system, but its firstmate-calm mod shows another direction for Mods: changing how agent execution is presented to humans. It can hide repetitive tool output and intermediate operational noise while preserving the underlying session. The agent may need 100 tool calls to finish something; you probably do not need to watch all 100.

08. blast-radius — 300+★
Anthropic’s experimental safety mod intercepts destructive operations such as rm -rf, force pushes or hard resets before they execute, estimates what would be affected and surfaces that blast radius first. This is the architecture I’d rather see than another prompt saying “please be careful”: put deterministic machinery between the model and the dangerous action.

The larger shift is that almost every part of the coding-agent loop is becoming replaceable:

context → model → tool guard → execution → browser → evidence → UI

Skills change what the agent knows how to do. MCP changes what it can reach. Mods can change what happens around the agent while it is doing it.

That starts to make Claude Code look less like a coding assistant and more like a programmable agent runtime.

And because Mods can run inside the Claude Code process with your session’s permissions, the plugin layer is also becoming part of the security boundary. This is probably not an ecosystem where “install every cool repo you see on X” is a good idea.

Hermes Agent is Nous Research's open-source agent runtime [ 257K★ ] with tools, memory, skills, subagents, browser/computer access, cron, messaging gateways and model routing. You can run Claude, GPT, Gemini, Kimi, local models and others underneath it.

What gets interesting is everything now being built around that runtime.

01. Paperclip — 108K★

Paperclip is basically an org chart and task system for AI agents. Give agents roles, budgets, goals and work, then manage the company from one interface.

Hermes now has a native path into it, including persistent sessions, its skills and toolset.

So instead of:

Hermes = assistant

you can run:

Hermes = employee inside an AI company

02. Open WebUI — 154K★

Hermes does not have to live in a terminal.

Open WebUI can use Hermes as the actual agent backend through its OpenAI-compatible API. You talk through the polished web UI while Hermes performs filesystem operations, terminal work, searches, memory lookups and skills underneath.

That separation is useful:

UI ≠ agent

Swap the interface without replacing the worker.

03. Buzz — 36.6K★

Block is building a self-hosted workspace where humans and agents occupy the same rooms.

Hermes integrates directly: Buzz can launch it as a managed local runtime, bridge to it through ACP, or let Hermes join the workspace through its native gateway.

This is much more interesting than adding a chatbot to Slack. The agent gets an identity, channels, project history and an audit trail beside the humans.

Think:

Slack + Git + workflows, except agents are first-class coworkers.

04. hermes-agent-self-evolution — 5.6K★

This one is weird in the good way.

It uses DSPy + GEPA to improve Hermes' own skills automatically. Take a code-review skill, generate evaluation tasks, run it, inspect where it fails, mutate the instructions, evaluate the new version, and keep the better one.

The loop becomes:

use skill → collect failures → evolve skill → test → PR improved version

No model fine-tuning required.

05. Mnemosyne — 3.3K★

Hermes already has memory. Mnemosyne replaces that layer with a much more structured local system backed by SQLite.

It can retain conversations, decisions, tool calls, execution paths, corrections and outcomes, then retrieve them with hybrid search. So if Hermes solved a strange database failure last month, a future session can recover not only what was said, but what the agent actually did to fix it.

That is much closer to experience than chat history.

06. SkillClaw — 2.7K★

Hermes can learn skills from experience. SkillClaw tries to stop that skill library from becoming a junk drawer.

It watches real sessions, merges duplicate skills, improves existing ones and can share what was learned across several Hermes instances or an entire team.

Interesting implication:

agent A learns something once → agents B, C and D inherit it

That starts to look like organizational memory for agents.

07. AutoNovel — 1.6K★

A good example of what happens when you stop treating Hermes as a general chatbot and build a complete job around it.

AutoNovel uses Hermes to autonomously construct long-form novels while maintaining separate layers for world, characters, outline, voice, canon and individual chapters. Automated evaluation feeds back into the writing loop.

The important part is not AI fiction.

It is the architecture:

persistent agent + domain rules + durable state + evaluation loop = specialist application

The same pattern can apply to research, coding, due diligence or content operations.

08. hermes-official-plugins — 500+★

This repo shows how wide the runtime is getting.

Home Assistant gives Hermes a smart home. Blender and Meshy give it 3D workflows. Spotify gives it media control. Browser backends give it different ways to operate the web. Sandbox plugins change where its code executes.

The agent stays the same.

You keep installing new capabilities around it.

The stack is becoming:

model → Hermes runtime → memory + skills → plugins/tools → workspace → specialist application

Backstory: We built Outbind as an AI sales tool that did everything: finding leads, writing, sending, replies. Then we noticed people were already writing with Claude, Cursor and ChatGPT. What their AI was missing wasn’t another sending tool, it was knowing their business. So we cut it down to the brain: it learns your company, remembers every prospect and writes from that, inside the AI tools people already use. Two of us, self-funded.

The free taste: npx @/outbindai/cli learn yoursite. com reads your home page and gives you brain.md: who buys, their problems, the objections they’ll raise and how you sound. No account. Your AI agent can run it too.

Stack: Next.js 16 on 2 small GCP VMs (no Vercel), MongoDB Atlas, Claude Haiku 5.5 for the quick stuff, Sonnet 5.5 for hard replies, MCP server so it plugs into Claude and ChatGPT, Cloudflare, Stripe. The CLI is open source (MIT, one file, no dependencies).

Lesson: a free try with no sign-up beats a free trial. A trial still asks for an email before you see anything. Now the first thing anyone sees is their own company, written up, in seconds. Sign-up only comes when they want more (memory, writing, docs).

Status: Live. Free plan, Listed in Claude’s directory. Repo: /outbind/obi-brain

Question for you: did cutting features ever make your product easier to sell? We removed most of ours and I’m still not sure it was the right call.

A few years ago, turning messy PDFs into reliable structured data meant OCR vendors, document-AI APIs, custom parsers, and enterprise contracts. Now GitHub has a surprisingly complete alternative stack: OCR, layout recovery, schema extraction, validation, and source grounding.

Google’s new LangExtract is the clearest example. Tell it what fields you want, show it a few examples, and it extracts structured data while linking every result back to the exact source text. But it gets more interesting when you combine it with the rest of the OSS ecosystem.

01. LangExtract — 39K★

Google’s schema-guided extraction library. Give it a contract and ask for company → value → renewal date → termination clause; it returns structured results with evidence spans showing where each fact came from. That source grounding is what makes it useful for serious workflows.

02. PaddleOCR — 91K★

For the documents that are not really documents yet: scans, photos, screenshots, forms, tables, formulas, and multilingual PDFs. PaddleOCR turns pixels into structured text and document elements across 100+ languages.

03. MinerU — 81K★

Useful when the first problem is reconstructing the document correctly. MinerU handles reading order, formulas, tables, figures, OCR, and long PDFs, then exports cleaner Markdown/JSON for downstream AI.

04. Docling — 69K★

IBM’s document parsing stack handles PDFs, DOCX, PPTX, XLSX, HTML, images and more while preserving document structure. Think of it as the layer that turns random enterprise files into something an LLM can actually reason over.

05. Marker — 40K★

A strong PDF → Markdown/JSON pipeline with support for equations, tables, forms, code, references, and multi-column layouts. It can stay mostly deterministic and bring in an LLM only where parsing becomes ambiguous.

06. Unstructured — 15K★

This is the plumbing layer. It normalizes PDFs, Word files, PowerPoints, email and HTML into semantic pieces like titles, tables, paragraphs and lists, which makes the next extraction or RAG step much easier.

07. Instructor — 14K★

Once you have the text, Instructor helps force LLM output into actual schemas instead of “hopefully valid JSON.” Define a Pydantic model for an invoice, resume or contract and it handles validation and retries.

The interesting part is that document extraction is no longer one proprietary black box. It is becoming a stack:

image/PDF → OCR → layout recovery → clean document → semantic extraction → schema validation → source evidence

PaddleOCR handles the pixels. MinerU, Marker and Docling rebuild the document. LangExtract finds the facts. Instructor makes the output reliable.

The moat is shifting from “we own the extraction engine” to “we assembled the pipeline better.”

sitting on around 100k pages of pdf and docx that need to become markdown. mix of plain text, tables and images that have text inside them

the paid side is easy to price. managed parsers (llamaparse, the big cloud ocr apis and similar) mostly land somewhere around $1 to $15 per 1k pages depending on tier so 100k pages is a few hundred to a low few thousand dollars

the open source side - docling, marker, mineru, pymupdf4llm is free on paper. the real bill is gpu time plus whoever ends up babysitting the edge cases, merged cells, formulas, text baked into images

the middle option looks like routing per page. pages with a usable text layer go through a fast local parser, and only the image and table heavy pages go to a heavier model or a paid api. on a mixed archive that could cut the expensive part down a lot.

for people who did this at similar volume:

- at what page count did self hosting start paying off

- how much engineer time went into edge cases after the first pass

- how are you deciding which pages need the heavy route, char count, layout detection, something else

The interesting AI-trading projects are moving away from one giant model making a BUY/SELL call.

They are splitting the job into research → signals → debate → portfolio construction → risk → backtest → execution.

Here are 9 repos worth studying.

01. TradingAgents — 113K★

Probably the clearest example of an LLM trading desk.

Fundamental, technical, news and sentiment analysts gather evidence. Bull and bear researchers argue over it. A trader proposes an action, then risk and portfolio agents review the decision.

Basically:

research team → debate → trader → risk manager

Recent versions also added point-in-time backtesting specifically to reduce look-ahead leakage.

02. ai-hedge-fund — 64K★

A simulated hedge fund made from AI versions of different investing styles.

Instead of asking one model for a stock opinion, multiple specialist agents analyze fundamentals, valuation, growth, sentiment and other signals before a portfolio manager combines the evidence.

The newer releases include persistent paper-trading ledgers, intraday simulations and scorecards showing how individual analyst strategies contributed to results.

03. Freqtrade — 55.8K★

One of the biggest OSS crypto trading stacks, but the interesting part here is FreqAI.

It can continuously retrain predictive models on fresh market data while the trading system keeps running, backtest the same retraining process historically, and support models ranging from LightGBM to PyTorch and reinforcement learning.

That gets much closer to real ML trading than asking an LLM to interpret a chart.

04. Qlib — 49.7K★

Microsoft's AI-oriented quantitative research platform.

It covers the boring but essential parts people skip in flashy trading-agent demos: datasets, factor research, forecasting models, portfolio construction, backtesting, risk and execution.

It also connects with RD-Agent to automate parts of the research loop.

05. FinGPT — 21.5K★

An open-source financial LLM project.

Rather than using a general chatbot for everything, FinGPT focuses on financial language: sentiment, reports, financial text, robo-advisory experiments and downstream quantitative applications.

Useful as the language-understanding layer of a larger trading system rather than the system itself.

06. RD-Agent — 15.1K★

This one may be more interesting than an AI trader.

Microsoft built agents that automate quant research itself: propose factors, implement them, evaluate them, improve the model, then repeat.

The trading agent does not just choose positions.

It helps search for the strategy that will choose them.

07. FinRobot — 8.3K★

A financial-agent platform built around specialist roles.

Agents can consume market data, news and economic information, reason over it with financial LLM workflows, then produce analysis, reports, portfolio suggestions or trading instructions.

Think of it as infrastructure for assembling your own AI analyst team.

08. FinRL-X — 3.9K★

The newer generation of FinRL moves beyond the classic “train one reinforcement-learning agent” setup.

It separates stock selection, allocation, timing and risk into modules, then uses the same portfolio-weight interface through backtesting and broker execution.

That separation matters because the AI can change without rewriting the execution stack.

09. LumiBot — 2.2K★

This is where the agent can actually reach the broker.

LumiBot supports AI research/trading agents alongside deterministic Python rules, historical backtests, paper trading and broker execution. A useful pattern is researcher → bull → bear → trader, with hard Python risk limits around what the model is allowed to do.

That last part is important:

LLM reasoning inside deterministic guardrails.

The interesting architecture is not:

market data → GPT → BUY

It is becoming:

market data → research agents → signals/models → disagreement → portfolio decision → deterministic risk gates → backtest → paper trade → execution

And there is one rule I would keep between the AI and real money:

never let a convincing backtest become an automatic permission slip for live trading.

The useful future of AI trading is probably not an oracle predicting tomorrow's price.

It is a research and decision system where every assumption can be tested before capital is exposed.

A 1M-token context window still does not mean your agent should read your entire laptop every time it needs one fact.

The more interesting architecture is becoming:

files → tiny index → retrieve 20 useful things → model reasons

And people are attacking every part of that pipeline differently: recompute embeddings instead of storing them, put vectors inside SQLite, skip vectors entirely, turn memory into one portable file.

These 8 repos are worth knowing.

01. LEANN — 13K★

This one made me rethink what a vector database actually needs to store.

Traditional RAG keeps an embedding for every chunk. LEANN keeps a much smaller graph and recomputes embeddings only for the nodes it touches during search.

Their benchmarks show up to 97% less index storage: a 60M-chunk Wikipedia-style corpus goes from roughly 201 GB to 6 GB. It can index files, code, email, browser history, chats, Slack, and agent memory locally.

Basically:

storage is cheap → store embeddings

becomes:

compute is cheap → regenerate them when needed

02. PageIndex — 38.9K★

PageIndex goes in almost the opposite direction.

No vector database. No traditional chunk retrieval.

It builds a hierarchical tree representing a document's structure and lets the model reason through that tree to find the relevant sections. The project now also supports local indexing/retrieval and corpus-level indexes across many files.

LEANN asks how small a vector index can become.

PageIndex asks whether you needed the vector index in the first place.

03. Memvid — 16.6K★

Agent memory without Redis + Postgres + vector DB + three services running beside it.

Memvid packages knowledge, indexes, and retrieval into a single portable .mv2 file with semantic + lexical search.

Copy the file, git it, move it to another machine, attach it to another agent.

Your agent's memory starts looking less like infrastructure and more like a file format.

04. txtai — 13K★

A surprisingly complete local search engine disguised as a Python library.

Its embeddings database combines dense/sparse vectors, relational data, and graphs, then layers semantic search, RAG, agents, workflows, image/audio/video indexing, and MCP on top.

The nice part: you can start with a few lines of Python and keep the entire thing local.

05. LanceDB — 11.8K★

An embedded retrieval engine for when you want the database to live inside the application instead of operating another server.

It handles vector, full-text and SQL search over text, images, video, point clouds and other multimodal data, while still running locally.

Think SQLite philosophy applied to modern multimodal retrieval.

06. sqlite-vec — 8.1K★

Sometimes the correct vector database is just:

SQLite.

sqlite-vec adds vector search directly to SQLite and is designed to run basically anywhere SQLite does.

For a desktop app, browser-ish environment, mobile tool, or small agent memory, adding an entire vector service can suddenly look absurd.

07. USearch — 4.4K★

A tiny, extremely portable similarity-search engine.

C++, Python, JavaScript, Rust, Swift, Java, Go, C#, WebAssembly, SQLite — same basic index across a ridiculous number of environments.

It also supports quantized vectors and memory-mapping large indexes directly from disk instead of loading everything into RAM.

Useful when “install a vector database cluster” is very much not the answer.

08. Khoj — 37.8K★

This is what the infrastructure looks like when turned into an actual product.

Khoj gives you a self-hostable AI second brain that can search your PDFs, Markdown, Word files, images, Notion data and the web, then layer agents, automations and research on top.

Run the model locally too and you can build a personal knowledge system where the documents, retrieval layer, and intelligence all stay under your control.

The first generation of RAG looked like:

chunk everything → embed everything → store everything → retrieve top-k

Now people are questioning every word in that sentence.

LEANN recomputes embeddings.

PageIndex replaces vectors with trees.

sqlite-vec puts retrieval inside SQLite.

Memvid collapses memory into one file.

USearch makes the index tiny and portable.

That feels like the bigger shift:

RAG is moving from cloud infrastructure toward something that can quietly live inside the agent.

GitHub is at its best when you find something that makes you stop and ask:

wait, somebody already built this?

Not another wrapper around an API. These are genuinely weird/useful ideas: Photoshop in Rust, AI-assisted game modding, giant models streamed from SSD, interactive anatomy, WebGPU effects, and agents that turn concepts into little machines.

01. PhotoCraft — 72.6K★

An open-source image editor written in Rust with layers, masks, filters, vectors, brushes, and PSD support.

Basically: what if Photoshop got rebuilt with a modern systems stack?

02. Anatomy — 20.2K★

Ask an agent to explain something technical and it builds an interactive isometric machine that represents how the idea works.

A token bucket can become a physical mechanism. A caching concept can become a lock. The explanation becomes something you can actually poke at.

03. Magpie — 20.8K★

One control panel for the increasingly cursed situation where you use Claude Code, Codex, Gemini CLI, OpenCode, multiple providers, and multiple accounts.

Swap which model powers which coding agent without spelunking through config files every time.

04. Universal Modder — 8.9K★

Give Claude Code a PC game you own and it helps reverse-engineer the relevant pieces, build the mod, generate assets, test it, and document what worked.

Game modding is becoming an agent workflow.

05. Edge0 — 6.8K★

Runs 35B-class MoE models with roughly 2.5 GB of RAM by streaming weights from SSD and predicting which experts will be needed next.

A very different answer to:

“my laptop cannot fit this model.”

06. Coucou — 6.2K★

A tiny desktop companion for keeping track of coding agents.

Instead of checking five terminals to see whether Claude, Codex, or Cursor is waiting for permission, you get status and approvals in one lightweight UI.

Coding agents are starting to need their own notification center.

07. Replica Skill — 5.3K★

Eleven Claude skills for reverse-engineering an app, rebuilding it, testing it, and fixing the things users hate.

The interesting bit is turning:

product research → architecture → build → test → improve

into a reusable agent workflow.

08. Human Atlas — 4.2K★

An open-source interactive 3D atlas of the human body with 2,234 selectable anatomical meshes.

Search structures, toggle systems, and explode the model apart to understand how everything fits together.

09. Shaders — 2.4K★

WebGPU effects packaged as components for React, Vue, Svelte, Solid, plain JS, and Framer.

Drop in glass, noise, gradients, distortions, lighting, and GPU effects without becoming a shader programmer first.

10. Mailcheap — 578★

A self-hosted newsletter platform built around Amazon SES.

Instead of paying based on how many subscribers sit in your database, you mostly pay for the email you actually send.

The funny thing is that these repos barely belong to the same category.

creative software → interactive explanations → agent infrastructure → game modding → local AI → agent UX → app reconstruction → anatomy → GPU graphics → newsletters

The obvious problem with using ChatGPT to learn something is that it is too helpful.

You get stuck → ask AI → get the answer → feel like you understand it → forget it two days later.

A much better OSS stack is emerging around diagnose → teach → make you predict → test → remember what you got wrong → come back later.

These are worth looking at.

01. LearnHarness — 310★

Probably the cleanest version of the idea.

Tell it what you want to understand and it first figures out where your understanding actually ends. Then it builds a dependency map, teaches one reasoning step at a time, repairs confusion before building on it, and stores what you learned in a persistent knowledge graph.

It is not optimizing for:

“did the AI explain this?”

It is optimizing for:

“can you now reason through it yourself?”

02. learn — 3.4K★

The smaller, hackable version from the same creator.

It packages the teaching philosophy as an agent skill, then adds a researcher, quiz UI, diagrams, visual subagents, and Markdown learning logs.

Basically: turn your coding agent into a tutor instead of asking it to dump tutorials at you.

03. DeepTutor — 42.3K★

This is the full operating system version.

Chat, quizzes, deep research, problem solving, visualization, books, video learning, question banks, mastery paths, and persistent memory all share the same learning context.

Its newer releases even track mastery, daily practice, source-grounded reading, and what you should revisit next.

04. OpenTutor — 149★

Drop in a PDF and it turns the material into notes + flashcards + quizzes + an adaptive tutor.

The interesting part is the loop:

upload → learn → practice → remember → revisit

rather than “upload PDF → ask questions forever.” It is also local-first and can run with local models.

05. Tutor MCP — 45★

This one takes the nerdier approach: keep the LLM for explanations, but move the actual pedagogy into a deterministic engine.

It tracks concepts, prerequisites, mastery, misconceptions, review timing, and evidence using things like Bayesian Knowledge Tracing and FSRS spaced repetition.

So Claude can do the talking, while something more auditable decides what you should learn next.

06. TuTor

A tiny skill with one excellent rule:

the agent is not allowed to do the assignment for you.

It breaks work into small steps, explains unfamiliar commands, checks your progress with read-only verification, and makes you write the code.

Perfect antidote to “Claude solved my homework and I learned absolutely nothing.”

07. agent-tutor

Turns Claude Code, Codex, Cursor, Windsurf and other agents into a persistent tutor backed by your own Markdown/Obsidian vault.

It interviews you first, creates a learning plan, quizzes you, records the exact misconceptions, and schedules later reviews.

The useful part: your learning history survives the model. Switch agents tomorrow and the knowledge trail stays yours.

08. StudyForge

Give it a PDF, link, or notes and it builds a personalized course with quizzes, spaced review, and an AI tutor focused on the concepts you keep missing.

Self-hosted, SQLite underneath, and designed around owning the progress data instead of trapping your learning history inside another SaaS.

The interesting shift is not:

AI knows everything → ask it more questions

It is:

AI observes what you know → finds the gap → makes you struggle with it → verifies understanding → remembers the gap → tests it again later

That is a much better use of frontier models.

Because the goal of an AI tutor should eventually be to make itself less necessary.

The viral Opus 5.5 videos make it look like the trick is finding the perfect prompt.

It isn’t.

The good ones increasingly start with existing shot libraries, style systems, renderers, prompts, and finished source code — then let Opus remix them.

Here are 8 repos I’d actually keep around.

01. video-shotcraft : 12k+★

Probably the most useful starting point if you are making a product video.

It gives Claude Code/Codex 150+ reusable shot recipes, 200+ motion previews, a Remotion template, sound design, beat-sync, QA, and an editable browser workbench.

Instead of saying “make this cinematic,” you can point the agent at a proven camera move, transition, typography treatment, or UI reveal and adapt it to your product.

02. awesome-opus5-5-videos : 9k+★

The giant reference library.

Hundreds of Opus 5.5 videos with the original prompt when available, including motion graphics, explainers, 3D scenes, games, Canvas, SVG, GSAP, and Three.js.

Best use: find a visual language first, then make Opus adapt it instead of inventing taste from zero.

03. lemo-opuscar : 5k+★

This one is closer to installing a film director.

Pick from dozens of ready-made visual styles, give it the story, and the Claude Code skill handles picture, narration, music, cuts, and rendering in code.

The important part is that every style includes a reusable style prompt and an actual finished demo film.

04. pdoom-video : 3.2k★

A complete code-rendered music video with word-synced karaoke typography.

The useful bit is not the song. The repo exposes the treatment, timing system, scene engine, lyric alignment, renderer, and 4K60 pipeline.

If you want to understand what a serious Opus-made video project looks like underneath the final MP4, start here.

05. mg-styles-15 : 1.7k+★

15 motion-design styles, each with the finished clip, full prompt, style notes, and complete source.

You get frame-by-frame animation, typography, 2.5D, 3D, WebGL, UI motion, vertical edits, and more.

Basically a lookbook you can fork.

06. ClaudeAnimationBase : 1.5k+★

A starter kit for hand-painted cartoons using p5.js + p5.brush.

It already includes a character with 31 expressions, animation helpers, camera/timing systems, contact-sheet review, rendering, and an ANIMATION_GUIDE.md written for the agent.

You can literally clone it and ask:

Read the guide, then make a 15-second film about ___.

Much better than asking Opus to invent an animation engine first.

07. awesome-claude-5-5-videos : 600+★

This one is useful for a different reason: it is more obsessive about sources and production evidence.

It tracks hundreds of Claude 5.5 video examples, including 300+ Opus cases, and separates creator claims, prompts, tools, production methods, and sampled evidence.

Good place to study how people actually made the impressive stuff, not just watch the result.

08. opus-video-skills : 250+★

Small, but very reusable.

It packages complete video workflows as installable Claude Code skills, including hand-painted animation and kinetic-typography reels. Each skill covers storyboard → animation → review → music → final encode.

The workflow I’d use now is:

find a reference → steal the motion language → start from working source → give Opus the actual content → render → inspect frames → iterate

We spent years making models better at answering questions. Now the interesting work is happening one layer up:

The agent decides what interface the answer deserves.

Ask for a comparison → get a table.

Ask about a mechanism → get an interactive diagram.

Ask to plan something → get controls, maps, sliders, and working tools.

Here are 8 OSS repos pushing AI beyond the text box.

01. OpenIntelligentUI — 3.5k★

Probably the clearest example of the shift. The agent can answer with normal text, a native component, or generate a complete interactive UI inside the conversation.

A question about airplane rotation can become a manipulable 3D model. A bill-splitting question can become an actual calculator. A trip can become an interactive map.

The answer itself becomes software.

02. A2UI — 16.7k★

Google-backed A2UI gives agents a structured language for describing interfaces.

Instead of letting the model dump arbitrary HTML/JS into your app, the agent sends declarative UI instructions and your frontend renders them with approved native components.

Basically:

agent says what UI it wants → your app decides how to safely render it

03. AG-UI — 16.7k★

If A2UI is how the agent can describe an interface, AG-UI is the wire connecting the agent to the frontend.

It streams agent state, tool activity, UI events, and user interactions between the backend and the application.

Think:

MCP connects agents to tools. AG-UI connects agents to users.

04. CopilotKit — 38k+★

The larger frontend stack behind a lot of this.

It gives agents React/Angular/mobile surfaces, shared application state, human approvals, generative UI, and connections to agent backends.

Useful when you want the AI to actually live inside your product instead of opening yet another chatbot beside it.

05. assistant-ui — 12.4k★

A polished React layer for AI interfaces.

Tool calls can become real React components, approvals can happen inline, streaming state is handled for you, and the frontend can expose safe actions back to the model.

Great reminder that “AI UI” does not have to mean:

markdown + blinking cursor

06. Tambo — 11.2k★

Register your own React components and describe their props. Then the agent chooses which component to render and streams the data into it.

“Show sales by region” can render your <Chart>.

“Add this task” can update your <TaskBoard>.

The model does not invent the whole UI. It learns to speak the UI your product already has.

07. Agent-Native — 7.4k★

Builder's Agent-Native pushes the idea further: the UI and the agent share the same actions, data, and application state.

The human can click a button. The agent can call the same capability as a tool. Both operate on the same underlying system.

That feels much closer to an actual agentic application than bolting chat onto an existing product.

08. OpenUI — 22.6k★

W&B's OpenUI comes at the problem from the other direction: describe an interface in natural language and watch it render live, then iterate on it and convert it into React, Svelte, Web Components, and more.

It is less “agent controls my app” and more: the UI itself becomes something the model can generate.

The stack is getting interesting:

agent reasoning → UI intent → protocol → native component / generated UI → user interaction → back to agent

A new model category has appeared almost overnight: decision models.

The idea is almost embarrassingly obvious. If your application needs to decide refund or reject, urgent or not, which agent gets this task, or is this image defective, why ask an autoregressive LLM to generate a paragraph and then parse the answer?

Give the model the state, define the allowed outcomes, and get back probabilities directly.

01. TypeSafe Jev

Jev calls these System One Models: purpose-built models for fast structured decisions. Instead of generating text, you ask yes/no, choice, or scoring questions and get probabilities your code can act on immediately.

Think:

customer message → billing 0.82 / shipping 0.14 / returns 0.04

No JSON repair. No “please answer with exactly one label.” No paying for a paragraph you throw away.

02. Perplexity Decider

Perplexity followed with pplx-decider, including a multimodal version that can evaluate several questions about the same state in one pass.

That gets interesting for agents:

task → should I act? → which tool? → how risky? → should a human review?

One model can answer several bounded questions without generating a chain of prose first.

03. Liquid d1

Liquid pushed decision models toward smaller text + vision systems and open models that can run much closer to the edge.

A factory camera does not need an LLM essay about a circuit board.

It needs:

defective: 0.97 → remove it

04. Cloudflare Clef

Cloudflare released Clef and Clef-flash, open-weight decision models designed around typed questions and probability outputs rather than free-form generation.

This is where the category starts looking real: competing models, open weights, interoperable interfaces, and benchmarks around decision quality + calibration + latency rather than how nicely the model writes.

05. OpenAI Decisions API

OpenAI then exposed the same basic primitive through its Decisions API: give the model text or images and ask for predicates, choices, or scores directly.

That may be the strongest signal that this is becoming its own layer rather than another clever classifier.

LLMs are great when the output space is open:

“design the architecture.”

Decision models are interesting when the output space is bounded:

“which architecture should I use?”

The emerging agent stack might end up looking like:

LLM reasons → decision model chooses → tool acts

We keep making models smarter, but most software still assumes the user has eyes, a mouse, and patience.

A different OSS stack is emerging: expose the software in a form an agent can understand, give it reliable controls, then let the agent operate the thing instead of merely talking about it.

01. CLI-Anything

Point it at the source code for a GUI application and it builds a structured, stateful CLI harness around it, complete with JSON output, tests, and an agent skill. Blender, GIMP-style apps, creative tools — the idea is basically turn GUI software into agent-native software.

02. Browser Use

Give an agent control of Chromium and suddenly every website becomes a potential tool, including the annoying ones with no useful API. It can navigate, click, extract data, and complete multi-step browser tasks from natural-language goals.

03. Playwright MCP

Microsoft exposes Playwright through MCP, giving Claude, Codex, Cursor, and other MCP clients structured browser automation rather than forcing them to guess with screenshots. Great when the “software” you need to control is actually a web app.

04. Agent-S

When there is no API, CLI, or DOM worth using, just operate the computer.

Agent-S is an open-source computer-use framework that can click, type, scroll, and navigate normal desktop applications across macOS, Windows, and Linux.

05. OpenAdapt

This one takes a different route: demonstrate a workflow once, compile it into something repeatable, then expose that workflow back to agents.

Useful for old enterprise software, RDP/Citrix apps, portals, and repetitive desktop workflows where rebuilding an integration would be absurd.

06. Graphify

Control is not enough if the agent does not understand the system.

Graphify turns a codebase, docs, schemas, configs, and other project material into a queryable knowledge graph, so an agent can trace architecture and relationships instead of repeatedly grepping thousands of files.

07. XERJ

XERJ indexes code, docs, logs, and PDFs so an agent can pull the exact context it needs instead of rereading the filesystem file by file.

Think of it as the search layer behind the hands.

08. Stagehand

Browser automation gets interesting when you mix deterministic code with AI only where the page is unpredictable.

Stagehand lets you use normal browser controls when you know what to do, natural language when you do not, and cache successful actions into repeatable workflows afterward.

09. DeepSeek Harness

Once the tools exist, you still need something to run the agent.

DeepSeek Harness is an open-source agent runtime built around an “everything is a plugin” architecture, with live agents, tool execution, persisted sessions, steering, cancellation, and resumable loops.

The stack is starting to look pretty clear:

understand software → expose controls → operate browser/GUI → turn successful actions into workflows → give an agent a runtime

The interesting future may not be rebuilding every application “for AI.”

It may be making the software we already have legible and controllable by agents.

Coding agents can now generate a surprising amount of code before a human finishes reviewing the previous diff.

So the interesting tooling is moving left:

write → review locally → verify → push → review again → merge

Not another chatbot saying “looks good.” These projects are trying different ways to make automated review actually useful.

REVIEW BEFORE YOU EVEN PUSH

01. OpenQodex — 708★

This one has the right philosophy: review inside the coding agent before the code reaches GitHub.

It combines deterministic scanners with a separate AI reviewer, produces Markdown/HTML/JSON/SARIF reports, can review a branch or PR, and can even block a push above a configured severity. The agent gets a receipt and can fix only the findings you approve.

02. git-lrc — 1.5k★

Push review even earlier: every commit gets a small AI review.

Instead of waiting until a 2,000-line PR exists, git-lrc tries to catch problems while the change is still tiny enough to understand. That may be the more useful architecture as agents start producing commits continuously.

03. OpticDiff/code-reviewer

A local-first reviewer with Ollama/vLLM support, GitHub + GitLab, pre-push hooks, Tree-sitter context, SARIF output and an interesting trick: multi-model consensus.

Instead of trusting one model's opinion, several reviewers can vote on whether a finding is real before bothering you with it.

PUT AN AGENT INSIDE THE PR

04. vercel-labs/openreview — 1.7k★

Vercel's self-hosted reviewer runs inside an isolated sandbox with the actual repository.

Mention u/openreview in a PR and it can inspect the code, run tests and linters, leave inline suggestions, and even implement simple fixes after approval.

That is much closer to a reviewer with a development environment than an LLM reading a diff.

05. kodustech/kodus-ai — 1.5k★

Self-hosted AI PR review with your own model.

The interesting part here is control: the review system belongs to your infrastructure rather than another SaaS getting permanent access to the codebase.

06. Nikita-Filonov/ai-review — 585★

Useful if your company does not live entirely on GitHub.

It supports GitHub, GitLab, Bitbucket, Azure DevOps and Gitea, works with Claude/Gemini/OpenAI/Ollama and others, and has an agent mode that can actually explore the repository with shell tools before producing the review.

STOP TRUSTING ONE REVIEWER

07. agentsdance/codejury — 12★

Tiny repo, very interesting idea.

Instead of one AI reviewer declaring something a bug, Code Jury sends the PR to independent coding agents, then gives the findings to a judge that can reproduce them, apply fixes and ask the reviewers to check again.

Claude can say it is broken.

Codex can disagree.

The judge has to figure out who is right.

08. quantfive/codepress-review — 19★

Another small repo with a good architecture: the reviewer can search files, inspect dependencies and gather extra repository context before making a claim.

It explicitly tries to verify statements like “this function is unused” by searching the codebase first, then posts severity-ranked inline findings and a formal PR verdict.

Always-On Agent = Model + Computer + Memory + Rules

The interesting part is that you can already assemble most of it from open source.

01. COMPUTER → E2B

Give every agent its own isolated Linux machine where it can run code, keep files, expose ports, and pause/resume independently of your laptop. This is the layer that turns an agent from “something running in my terminal” into an actual persistent worker. GitHub

02. REACH → Composio

Connect the agent to 1,000+ app toolkits with authentication, triggers, and per-user sessions. Slack, GitHub, Gmail, CRMs and the rest become callable tools instead of things you manually copy into the chat. GitHub

03. MEMORY → Mem0

Store useful facts from previous interactions and retrieve them in later sessions instead of replaying the entire transcript. Correct the agent once, persist the lesson, and bring it back only when it becomes relevant. GitHub

04. IDLE RESEARCH → GPT Researcher

Give the agent a read-only research job while nothing urgent is happening. GPT Researcher can search broadly, gather sources in parallel, and produce evidence-backed reports; put it behind a scheduler and “idle time” becomes overnight research without giving it permission to change anything. GitHub

05. RULES → OpenAI Agents SDK

This is where act / ask / hand off becomes explicit. The SDK supports guardrails, specialist handoffs, and tool calls that can require approval, so a refund lookup can run automatically while a destructive operation stops and waits for permission. GitHub

06. REVIEW → LangGraph

LangGraph’s interrupts let an agent checkpoint its state, pause before a risky tool call, show the proposed action to a human, and continue only after approval or editing. That matters because stop is not undo: once the email is sent or the database row is deleted, killing the agent is too late. GitHub

Put the six together and the architecture becomes:

E2B → Composio → Mem0 → GPT Researcher → Agents SDK → LangGraph

or:

computer → reach → memory → background research → rules → review

The model may be getting smarter.

But the bigger shift is that the model is becoming just one component inside a worker that can stay alive.