Skills and a CLI that let AI coding agents mod PC games you own

Modding a game usually means working out the engine, finding the right loader, reading decompiled code, making art and sound, and testing in the running game. This project packages that work as skills in the Agent Skills format, so an agent can follow the same loop each time.

The loop starts with a search of a knowledge base of field notes, then recon of the game, a safe lab with backed-up saves, reading the real code, building one working slice, generating assets, testing in the game, recording and packaging. At the end, the agent can write a field note and open a pull request so the next agent starts with what it learned.

It works with several agents: Claude Code, Codex, Gemini CLI, Copilot, Cursor and OpenCode. Asset generation uses fal, which needs an API key. The README also names ComfyUI for local images and two paid sprite services as options.

Read more on interesting repos · GitHub

MCP server that lets AI agents reverse engineer apps, binaries and websites locally

Sometimes you see a feature in an app and want to know how it works, but you don't have the source. REA gives your AI agent tools to look inside the app: its files, scripts, binaries and network traffic. The agent can then explain the behavior and help you build something similar.

It runs as an MCP server, a standard way for agents to call outside tools. The agent asks about a local target, REA inspects and traces it, and returns code, references and a list of unknowns. The same workflows are available as terminal commands. Analysis runs on your machine.

For native binaries REA can use an existing Hopper, Ghidra or IDA install. Many other formats, such as Go and Rust binaries, GGUF and safetensors model files, Godot PCK archives and static JavaScript, are read by built-in inspectors with no extra software. Results state their evidence and limitations.

Read more on interesting repos · GitHub

Local proxy that serves CLI AI accounts as OpenAI, Gemini and Claude APIs

Many AI coding tools come with their own command-line login, and each speaks a different API dialect. That makes it hard to use those accounts from your own scripts or from apps that expect a standard API.

CLIProxyAPI runs as a local server. You sign in with your provider accounts, then point any OpenAI (including Responses), Gemini (including Interactions) or Claude-compatible client or SDK at it. It can hold several CLI accounts at once.

The README lists Kimi, OpenAI (including Codex OAuth), Anthropic Claude, Google Gemini (API, AI Studio, Vertex AI, Gemini CLI, Antigravity), xAI Grok, Meta Muse and Devin. Which models you get depends on the account and channel. The part of the README provided is mostly provider and sponsor listings and has no install steps. A separate desktop client, EasyCLIProxyAPI, adds a graphical setup.

Read more on interesting repos · GitHub

Run a persistent team of Claude Code and Codex agents from one YAML file

Running several AI coding agents usually means a pile of terminal windows with no shared memory and no clear owner for each task. OpenRig treats the agents as a team. You describe the team in YAML, and it starts each agent in a tmux session with a role.

You talk to a lead agent about the outcome you want. The lead can hand work to specialists such as a builder, a reviewer or QA, and tasks are tracked in a queue. A terminal dashboard shows each agent's model, state and context. After install, a built-in operator agent helps you pick a first team.

The README describes three ready-made teams. Starter pairs a Claude Code builder with a Codex reviewer. Workshop adds a lead and QA. Factory has seven agents for longer product work. Setup writes provider hooks and trust settings on your machine, and the README lists these changes in detail.

Read more on interesting repos · GitHub

A desktop AI app builder that runs on your own machine with your own API keys

Tools like Lovable, v0 and Bolt let you describe an app and have an AI build it, but they run in the cloud. Dyad does the same kind of job as a desktop program on your own computer.

You bring your own AI API keys, so you pay the model provider directly and aren't tied to one vendor. The README says this keeps it private and free of lock-in.

The README is short, so details on how it builds apps are thin. The repo topics point to Next.js and React projects and to models such as OpenAI, Anthropic, Gemini, DeepSeek, Qwen and Ollama. Check dyad.sh for specifics.

Read more on interesting repos · GitHub

Most software is built for people clicking through windows. AI agents work best with text commands and structured output. CLI-Anything fills that gap by creating a command-line harness around an application, so an agent can call it the way a person calls git or ls.

The generated CLIs are Python tools built on Click. They give both human-readable and JSON output, and each comes with a SKILL.md file that tells an agent how to use it. A HARNESS.md guide describes the method for building a new harness for a given piece of software.

CLI-Hub is the companion registry. You install it with pip, then use it to browse, install, update and remove CLIs. The README lists many community harnesses, including Blender, FreeCAD, Krita, Obsidian, QGIS, n8n and Godot. Contributors add new ones by pull request.

Read more on interesting repos · GitHub

Coding is full of small chores: finding where something lives, making similar changes across files, writing commit messages, working out what unfamiliar code does. Claude Code takes these on through requests you type in plain language.

You install it, move into a project folder and run `claude`. From there it can look at your codebase, explain parts of it, carry out routine tasks and handle git workflows. The README says you can also use it in your IDE or tag @claude on GitHub.

The README doesn't compare it with other tools. What it stresses is the terminal-first setup and the way it works on your existing project. The repo also includes plugins that add custom commands and agents, and the full docs live on a separate site.

Read more on interesting repos · GitHub

Git worktrees let you check out several branches at once, each in its own folder. That helps when you run several AI coding agents, such as Claude Code or Codex, because they can't overwrite each other's changes. The plain git commands are clumsy, though. Starting a new worktree means typing the branch name several times and then changing directory by hand.

Worktrunk addresses worktrees by branch name and works out the folder path from a configurable template. `wt switch -c feat` creates a branch and worktree and moves you into it. `wt list` shows every worktree with its status. `wt merge` squashes, rebases, merges and cleans up. `wt remove` deletes the worktree and branch. Shell integration is what lets these commands change your directory.

The README compares it only with plain git. On top of that it adds hooks that run on create or merge, optional LLM-written commit messages, an interactive picker, and shared build caches such as `target/` and `node_modules/` on filesystems that support copy-on-write (APFS, btrfs, XFS).

Read more on interesting repos · GitHub

When you run several coding agents at once, the hard part is not watching them. It is remembering where you were each time you switch. Agents ask questions you skim past, finish work you never reviewed, or wait on something you forgot.

Logic Loop wraps your agent terminals in a desktop app with a side panel. It reads structured signals from each agent, such as lifecycle hooks, JSONL transcripts or plugin events, rather than scraping the screen. The panels are SQL views over an append-only event log. An LLM is used only for ambiguous cases, like checking whether your reply answered every question the agent asked.

The README says other tools show what the agents are doing, while this one tracks what you need to do. It observes and displays, and never writes into a running session on its own. Each agent adapter installs into that agent's config only after you click, and it removes itself when you switch it off.

Read more on interesting repos · GitHub

Once you have a few Claude Code sessions open, it is hard to tell which one is waiting for an answer, what it changed, or what the week has cost. This project is a small Node.js server that reads the session files in ~/.claude and shows the answers on one page, updated live.

It is read-only. It never writes to Claude's files, has no npm dependencies, needs no API keys, and listens only on 127.0.0.1. The one outside call is optional: it asks Anthropic's usage API for your quota meters, using the sign-in Claude Code already has.

Instead of switching between terminals, you watch a departures-style board. A waiting session turns amber and shows its question or the command awaiting permission. You can open any transcript, read a diff of the files a session edited, or resume it in the right folder.

Read more on interesting repos · GitHub

Claude Code expects to talk to Anthropic's API. Clodex sits on your machine and pretends to be that API. It rewrites each request into the format the ChatGPT Codex backend uses and sends it with your ChatGPT login.

When the backend replies, Clodex converts text, tool calls, reasoning, token counts and errors back into Anthropic's format. One shared piece of code handles streaming and buffered replies, so the client sees the same content either way.

Other Claude Code proxies route to many providers. Clodex supports only Codex, and has no API-key mode. The author argues the narrow focus makes tool calls, usage counts and errors more reliable. The README warns that the proxy has no authentication, and that using your ChatGPT credentials this way puts your account at risk.

Read more on interesting repos · GitHub

Explaining a bug or a design change to an AI agent in words is slow. ScreenContext lets you record the screen instead, then pass that recording to an agent that can process video. The agent can then fix the bug, write a ticket, or help make a product video.

It works in a few steps. You start recording with a global shortcut while your agent's app is active, and stop with the same shortcut. The recording opens for review. One click or shortcut copies the local MP4 path and switches you back to the agent, where you paste it and add your request.

It does not upload anything for you. If your agent cannot read a local path, you attach the MP4 yourself. It also works as a plain screen recorder with a library of local MP4 files. The README says there is no account, cloud upload or analytics. It is built with Swift, SwiftUI and ScreenCaptureKit.

Read more on interesting repos · GitHub

When you run several coding agents in different terminal tabs, it is easy to miss that one is waiting for you, or to hit a usage limit without warning. NotchHUD puts that information in a pill at the top of the screen, such as '2 working · 1 needs you'. Click it to expand a panel with each session and your usage.

Claude Code sessions report through hooks that setup adds to ~/.claude/settings.json, which send events to a local server on your Mac. Codex sessions are detected by watching its session files. Usage numbers come from Anthropic's and OpenAI's usage endpoints, using tokens the tools already store. You can switch that off to get estimates only.

It also puts a pace mark on each usage meter, sends notifications as you near a limit, and can run a scheduled 'hi' to Claude so your 5-hour window is already running when you sit down. It warns when your active gh account does not match the rules you set for a repository. The README says nothing leaves your Mac except the usage calls and an update check.

Read more on interesting repos · GitHub

OpenClaude is a command-line coding assistant. You open it in a project folder, describe a task, and it can run shell commands, read and edit files, search code, and call tools for you. It streams its output as it works.

The main idea is that the model behind it is your choice. You can point it at a hosted service such as OpenAI, Gemini, OpenRouter, DeepSeek or Groq, or at a model on your own machine through Ollama or LM Studio. A /provider command walks you through setup and saves profiles so you can switch later.

It keeps its own config under ~/.openclaude and does not read Claude Code settings, so Claude Code does not need to be installed. It also supports background sessions, resuming or forking past conversations, a headless gRPC server, and a bundled VS Code extension.

Read more on interesting repos · GitHub

Radiant is a desktop app for working with coding agents on your own machine. You point a chat at a project folder, and the agent can read and write files and run shell commands there. By default it asks before each command, and every tool call shows up in an activity panel next to a real terminal.

It talks to many providers, including Anthropic, OpenAI, OpenRouter, xAI, Groq and Mistral, and to Ollama or LM Studio for local models. You can sign in with a subscription you already pay for, such as Claude, ChatGPT or GitHub Copilot, or paste an API key. Chats are stored in a neutral format, so you can switch models mid-conversation and keep your context.

Beyond single chats, it has a task board, loops and graphs. A loop is a list of steps where each step must pass a check, such as a command that exits 0, before the next begins. A graph runs steps in parallel unless one really reads another's output. It is built with Electron, React and an Express server, and the Mac app targets Apple Silicon.

Read more on interesting repos · GitHub

Claude Code normally runs in a terminal on the machine where your code lives. This project puts a Telegram bot in front of it. You message the bot in plain language, and it passes the request to Claude Code, which works inside a directory you approved and sends back the result.

The bot runs on your computer or a server and uses the Claude Code SDK, with the CLI as a fallback. It saves a session for each user and project folder, so a conversation can resume where it stopped. Settings live in a .env file: your bot token, the approved directory and the Telegram user IDs allowed to use it.

Besides chat, it can react to outside events. A small API server takes GitHub webhooks, and a cron-style scheduler runs recurring tasks. Claude's answers are sent to the Telegram chats you list. It has two modes: a conversational default, and a classic mode with 13 terminal-like commands and buttons.

Read more on interesting repos · GitHub

Modular Platform is a set of tools for building and deploying AI. This repo contains the open-source parts: the Mojo language pieces and the MAX framework for running models.

Mojo is a programming language, and the repo includes its standard library and compiler folder. MAX is the other half. It has an accelerator kernel library, an inference server with an OpenAI-compatible endpoint, and model pipelines written as Python graphs.

The README does not compare the project to other tools, so this page won't either. Not everything is open to contributions: the maintainers say they aren't accepting changes to the Mojo compiler yet. MAX usage and distribution fall under a separate Modular Community License.

Read more on interesting repos · GitHub

Aura Code is a command-line coding agent. You describe a task in plain English. It reads your code, plans, makes changes, runs commands to verify them, and reports back. It is model-agnostic: you pick the provider, or point it at a local model through Ollama or LM Studio.

It keeps lessons between sessions in ~/.aura/memory/ on your computer, such as what broke last time and what your build needs. An optional layer called Archimedes tries each task with a small local model first. It tracks how often that model succeeds on similar tasks, and a larger cloud model takes over when the local one is unproven or fails a check.

The README contrasts Aura with fixed coding-agent products: skills, plugins and MCP servers are ordinary files you can edit. Besides the terminal UI it offers a web studio, a Telegram bot, and a lean chat mode called Gazelle that skips tool schemas to save context. The project is young, and the token-saving figures come from the authors' own measurements.

Read more on interesting repos · GitHub

Codex runs on your Mac, so you normally have to sit at it to watch tasks or approve actions. Microdex puts a control panel on your iPhone, modelled on the layout of the Codex Micro hardware: six task keys, six command keys, a joystick and a reasoning dial. It is an independent community project, not made by OpenAI or Work Louder.

It has two parts. A CLI called microdex-cli runs a bridge on the Mac. The bridge starts the Codex App Server that ships with the Codex app and talks to it over a local connection. The iPhone app pairs with the bridge by scanning a QR code. Traffic goes through a Cloudflare relay, so the phone works on Wi-Fi or mobile data and you open no router ports.

The README says commands and task state are encrypted between phone and Mac, so the relay only sees ciphertext. The bridge does not ask for your OpenAI credentials. An optional native mode makes Codex see a synthetic Micro device, for closer parity with the physical keyboard.

Read more on interesting repos · GitHub

Rebuilding a page from a design or screenshot is slow, repetitive work. This project hands the first pass to an AI model. You give it an image, and it returns code in the stack you pick.

It's a web app with a React and Vite front end and a FastAPI back end. The back end sends your image to a model from OpenAI, Anthropic or Gemini. With more than one key, it can compare several models per generation. Gemini also pulls real logos and images out of your screenshot. Replicate handles image generation, background removal and image editing. An optional preview step lets the agent render its own page in headless Chromium and check how it looks.

The README also points to a hosted version at screenshottocode.com if you'd rather skip setup. Running it yourself means paying for your own model API keys. The README says local Ollama models work but give poor results.

Read more on interesting repos · GitHub

The AI SDK is a TypeScript library for adding language models to web apps. It gives you one set of functions for many model providers, so switching models is mostly a matter of changing a model name.

On the server, you call functions like generateText to get text, or ask for structured output that matches a Zod schema. For agents, ToolLoopAgent runs a model that can call tools in a loop. On the client, a separate UI module offers hooks such as useChat for building chatbots and interfaces that show tool results.

The obvious alternative is using each provider's own SDK. Here, model strings go through the Vercel AI Gateway by default, or you can install provider packages like @ai-sdk/openai and @ai-sdk/anthropic to connect directly. It is made by the Vercel and Next.js team and works with Next.js, React, Svelte, Vue, Angular and Node.js.

Read more on interesting repos · GitHub

Coding agents work best when left alone for a while, but running them directly on your computer is risky. Sandcastle gives you a function, run(), that starts an agent in an isolated environment, lets it work on a branch, and brings its commits back to your repository.

You pick an agent (the README shows Claude Code), a sandbox provider, and a prompt, either inline or from a file. The agent loops up to a set number of iterations and stops early when it prints a completion signal. The result lists the commits made and the branch used.

It is a library, not a hosted service or chat app. You write ordinary TypeScript to chain steps, such as an implement run followed by a review run in the same warm sandbox. Docker and Podman use bind mounts, Vercel uses cloud microVMs, and you can write your own provider.

Read more on interesting repos · GitHub

When an error hits production, someone usually has to dig through logs, recent commits and code to find the cause. The same error can also page people again and again. DAA tries to take over that first investigation.

An error arrives through a webhook (Sentry, Datadog, Prometheus, CloudWatch) or through a small Python SDK. DAA fingerprints it with SHA-256, so an error it has already seen is suppressed. For a new pattern, a LangChain ReAct agent looks at recent git commits, app logs, traces and the source code, using AST navigation to find the relevant lines. It then pushes a branch and opens a pull request with a code fix, a root-cause explanation and a postmortem summary.

Plain alerting tells you that an error happened. DAA aims to hand you a proposed fix to review. The agent has a hard cap of 8 tool calls to limit LLM cost. It can run as one Docker container with no database, or as a fuller stack with Postgres, RabbitMQ and an admin UI. It can also run air-gapped with a local Ollama model.

Read more on interesting repos · GitHub

Reasonix is a coding agent for larger software tasks. You give it a goal, such as implementing the TODOs in a file, and it works through the code using tools. One local engine sits behind every front end: a terminal UI, the Studio desktop app, a browser, and editors that speak ACP, such as the VS Code extension.

Long autonomous runs can be hard to follow, so Reasonix adds guardrails. Plan mode, permissions, a workspace sandbox and per-turn checkpoints are meant to keep a run readable and let you rewind it. Providers, the agent, enabled tools and plugins are all declared in a reasonix.toml file.

DeepSeek comes as a preset, and any OpenAI-compatible endpoint can be added as a config entry. You can also run two models together, one as planner and one as executor. Tools come from MCP servers or Extension Protocol sidecars. It ships as one static binary. There are two lines: 1.x is stable, and 2.x (Studio) is a fast-moving pre-release.

Read more on interesting repos · GitHub

Open Code Review (the `ocr` command) is an AI code review tool that began as Alibaba's internal review assistant. It reads a Git diff, sends the changed files to an LLM you configure, and returns structured comments pointing at exact lines. The agent can open whole files, search the codebase and look at other changed files, so the feedback goes beyond the diff itself.

The README says general-purpose agents used for review tend to skip files on big changes, report wrong line numbers, and give uneven quality. This tool answers that with a hybrid design. Plain code decides which files get reviewed, groups related files into bundles that each run as a sub-agent, matches review rules to each file, and runs separate modules that check where comments land and whether they hold up. The LLM agent handles the judgment calls and fetching extra context.

The README compares it with Claude Code used for review. On the authors' own benchmark of 200 real pull requests, they report higher precision and F1 with the same model, about one ninth of the tokens, and lower recall. Treat those numbers as the project's own claims.

Read more on interesting repos · GitHub

Pi is a monorepo that holds a coding agent you run in the terminal, plus the libraries it is built on. These include a multi-provider LLM API, an agent runtime with tool calling, and a terminal UI library.

The agent keeps its core small. It leaves out features such as sub-agents and plan mode on purpose. You either ask Pi to build what you want, or install a package that adds it. Extensions, skills, prompt templates and themes can be bundled as Pi packages and shared through npm or git.

You can use it interactively, script it in print or JSON mode, drive it over RPC, or embed it in your own app with the TypeScript SDK. Pi has no built-in permission system. It runs with your user's permissions, so the README suggests Docker or a sandbox if you need limits.

Read more on interesting repos · GitHub

AI chat apps usually cannot touch your computer. Desktop Commander fixes that by running as an MCP (Model Context Protocol) server. The chat app connects to it and can then run commands, read and write files, and manage processes on your machine.

It builds on the official MCP Filesystem Server and adds search and edit tools. The AI can make small, targeted text replacements or rewrite whole files. It can search code with ripgrep and run code in memory (Python, Node.js, R) without saving a file. It also reads and edits Excel, PDF and Word files.

The README says it works through your client's subscription, so you do not pay API token costs. It works with Claude Desktop, Cursor, Windsurf, VS Code with Copilot, Cline and other MCP clients. The safety guardrails are a command blocklist and symlink protection. The README says plainly that these are not a sandbox. For stronger isolation it offers a Docker install.

Read more on interesting repos · GitHub

Code editors and AI coding agents usually need a custom integration for each pairing. ACP is a protocol that standardizes the messages between them, so an editor that speaks ACP can work with any agent that speaks it.

This repository holds the protocol's definitions rather than a finished app. The root Rust crate, agent-client-protocol-schema, models the wire messages: requests, responses, notifications and JSON-RPC envelopes. Generated JSON Schema files for versions 1 and 2 are included, and SDK generators can use them to produce client code.

Compatibility is negotiated at runtime. The two sides exchange a protocolVersion during initialize (the current stable version is 1), then use declared capabilities to learn which optional features each supports. The README warns against inferring wire compatibility from the crate or schema release number.

Read more on interesting repos · GitHub

If you run several coding agents at once, such as Claude Code or Codex, you end up with a pile of terminal tabs. Some agents are working, some are waiting for an answer, and it is hard to tell which is which. Closing your laptop or losing an SSH connection can also interrupt the work.

herdr runs a background server that owns the terminals. You attach a client to it, split panes, and start your agents inside them. Closing the client or dropping SSH leaves the terminals running, and you reattach later by typing herdr again. Each pane is labeled working, blocked or idle. You can also add saved SSH machines and see local and remote agents in one window.

It does not wrap or replace your agents. It manages their terminals, much as tmux does, but it adds agent status and a CLI and socket API. Agents can use that API to open panes, send prompts to each other, and wait until another agent is blocked. It ships as one Rust binary and runs inside the terminal you already use.

Read more on interesting repos · GitHub

AI coding tools cap usage in windows of a few hours, a week or a month. It is easy to start a long task and hit the limit halfway. CodexBar keeps those limits visible in the menu bar, with a countdown to each reset.

It runs as a menu bar app on macOS 14 or later, with no Dock icon. You get one icon per provider, or one merged icon with a switcher. It reads usage from each provider in whatever way that provider allows: OAuth, API keys, browser cookies, local files or the provider's own CLI. The README says no passwords are stored.

The README lists many providers, including Codex, Claude, Cursor, Gemini, Copilot, OpenRouter and Mistral. It also ships a command-line tool and a Qt 6 desktop app for Linux, and it polls provider status so incidents show up as badges on the icon.

Read more on interesting repos · GitHub

If you run several Claude Code or Codex sessions side by side, it's hard to tell which one is waiting for you. Native macOS notifications say little, and with many tabs open the titles become unreadable. cmux is a terminal app built to solve that.

It is written in Swift and AppKit, not Electron, and uses libghostty to draw the terminal. It reads your existing Ghostty config for themes, fonts and colors. A sidebar lists each workspace with its git branch, linked PR, working directory, listening ports and latest notification. When an agent is waiting, its pane gets a blue ring and its tab lights up. Notifications come from standard terminal escape sequences or from a `cmux notify` command you can call from agent hooks.

The author says other agent orchestrators they tried were mostly Electron or Tauri apps that lock you into one workflow. cmux describes itself as a set of building blocks: a terminal, a browser, workspaces, splits, and a CLI and socket API. You decide how to combine them.

Read more on interesting repos · GitHub

Running more than one coding agent at once gets messy fast. Each agent needs its own copy of the code so they don't overwrite each other, and you need a way to see which one has finished. Orca handles both. It gives each agent an isolated git worktree and shows them all in a single window.

It works with any agent that runs in a terminal. The README lists Claude Code, Codex, Cursor, OpenCode, Pi, Goose, Cline, Amp and many more. You use your own subscriptions. Orca adds terminals, a code editor, an embedded browser, diff review, and GitHub and Linear task views around them.

It is an agent-focused IDE rather than an agent itself. You can send one prompt to several agents, compare what they produce, and merge the best result. You can also check on agents from your phone, or run them on a remote machine over SSH.

Read more on interesting repos · GitHub

Rebuilding an existing website by hand is slow. You have to study each section, copy spacing and colors, and guess how menus and animations behave. This template hands that work to an AI coding agent. You give the agent a URL, and it produces a Next.js app that imitates the page.

It works through a skill called /clone-website that runs in stages. The agent takes screenshots, pulls out design values, and scrolls, clicks and hovers to see how the page behaves. It writes a spec for each component using exact computed CSS values. Builder agents then work in separate git worktrees, one per section. Finally the work is merged and compared visually with the original.

The project is a starter template, not a hosted service. It uses Next.js 16, React 19, shadcn/ui and Tailwind CSS v4. The README recommends Claude Code with Opus 5.5 and says Codex CLI, Cursor and OpenCode are also supported. It also lists uses it is not meant for: phishing, impersonation, passing off others' designs, and ignoring a site's terms of service.

Read more on interesting repos · GitHub

When coding agents write much of your code, sloppy changes can slip into pull requests. no-mistakes adds a gate between your branch and your real remote. You run `git push no-mistakes` instead of `git push origin`.

The gate makes a disposable worktree, so your own checkout is left alone. There it runs a pipeline: review, test, docs, lint, push, PR and CI. Each step either passes or stops with a finding. Safe, mechanical fixes are applied automatically. Anything that touches your intent goes to you to approve, fix or skip.

Only after every local check is green does the branch go to the push target, and the PR is opened for you. If CI fails later, the pipeline can repair it and push the fix, sending it back through review when it cannot show the fix builds on what you already reviewed. It works with many coding agents, such as Claude Code, Codex, OpenCode, Copilot and Cursor, with ordered fallbacks.

Read more on interesting repos · GitHub

Coding agents usually explore a project by grepping and reading files one at a time. That burns tokens and many tool calls. This project parses your repository once, stores the result as a graph, and lets the agent ask the graph directly.

It uses tree-sitter to build syntax trees for 162 languages, all compiled into one native binary. For 12 languages, including Python, TypeScript, Go, Rust, Java and C++, it adds a hybrid LSP step that resolves types more accurately. The graph lives in SQLite on your machine. The README says nothing leaves it and no API key is needed.

The README compares it with file-by-file exploration. Its preprint reports 10x fewer tokens and 2.1x fewer tool calls across 31 repositories, with 83% answer quality. Those are the authors' own numbers. It also bundles a 3D graph viewer and a shared background daemon, so several agent sessions can use one index.

Read more on interesting repos · GitHub

Rilable is an iPhone app for building apps by chatting. You describe what you want, a Claude-powered agent writes the code, and the result goes live in the cloud. You preview it without leaving the app.

Web prompts become static web apps served from Daytona sandboxes. Mobile prompts become SwiftUI apps compiled by Chorus cloud Xcode and shown in a browser-based iPhone simulator. Build status streams to the app through Convex subscriptions, and follow-up messages edit the project.

It runs on your own Convex deployment and API keys, with no sign-up or waitlist. The README says the UI is a clone of Lovable's mobile app, meant for personal use. It also warns that the backend functions have no authentication, so anyone with your deployment URL could start builds on your accounts.

Read more on interesting repos · GitHub

Joining a big codebase is slow because you don't know where to start. Understand Anything runs a multi-agent pipeline over your project and saves a knowledge graph as a JSON file. Each file, function, class and dependency becomes a node you can click, with a plain-English summary and its relationships.

You use it through slash commands inside your AI coding tool. /understand builds the graph, /understand-dashboard opens it in the browser, and commands like /understand-chat and /understand-explain let you ask questions about the code. Later runs only re-analyze changed files, so they use fewer tokens than the first run, which can be costly on large projects.

The graph is plain JSON, so you can commit it and teammates can open the dashboard without an LLM or API key. It started as a Claude Code plugin, and the README lists installers for Codex, Cursor, Copilot, Gemini CLI, OpenCode and others. It can also build a graph from a Karpathy-style LLM wiki.

Read more on interesting repos · GitHub

Most API wrappers map one endpoint to one command. An agent then has to read docs, guess flags, and spend tokens on long JSON replies. CLI Printing Press tries to produce a CLI that an agent can use correctly on the first try.

You run it as a slash command inside Claude Code, for example /printing-press Notion. It reads the official API docs, studies popular community CLIs and MCP servers, and can capture browser traffic when no public API or spec exists. It then generates a Go CLI (built with Cobra) and an MCP server that share the same client, store and auth.

The key difference is a local SQLite layer. Data syncs down, gets full-text search, and can be queried offline. That allows commands like stale, health or bottleneck that join across resources, which a stateless wrapper can't do. Output is a table in a terminal and JSON when piped, with typed exit codes and a compact mode to cut tokens. Each run also scores and checks the result, including a live API smoke test.

Read more on interesting repos · GitHub

A coding agent harness is the program that connects a language model to your files, shell and tools so it can work on code. jcode is one of these, with a terminal interface, written in Rust. It runs on Linux, macOS and Windows.

Its main pitch is resource use. Sessions share one daemon, so each extra session adds only a few megabytes. The README says Claude Code runs a separate process per session. It includes benchmarks against Claude Code, Codex CLI, OpenCode, Copilot CLI, Cursor Agent and others, measured on the author's Linux machine. Treat those as the author's numbers, not independent results.

It also has an agent memory system. Each turn is turned into a vector and compared with a graph of stored memories, and relevant ones are put into the conversation without the agent calling a tool. A side agent extracts new memories, and a background mode tidies old ones.

Read more on interesting repos · GitHub

Claude Code works better when it has clear project rules and checks that always run. This kit supplies them ready-made: a CLAUDE.md with 11 numbered rules, slash commands for common jobs, hooks that run automatically, and skills that give Claude topic knowledge such as Docker, MongoDB or accessibility.

It is a scaffold, not an app. You install it into ~/.claude with npx, or clone it and use /new-project to generate a new project with the tooling copied in. You can also merge it into an existing project with /convert-project-to-starter-kit, which makes a safety commit first so you can undo it.

The kit supports two ways of working. In the classic way you drive with commands like /review and /commit. In the MDD way, now a separate npm package, Claude writes documentation and tests first and asks for your approval at each step.

Read more on interesting repos · GitHub

Symphony is from OpenAI. It moves you from watching a coding agent work to managing the work itself. You put tasks on a board, and Symphony makes sure agents pick them up and finish them.

In the demo, Symphony monitors a Linear board for new work and starts an agent for each task, each in its own isolated run. The agents report back with proof of work: CI status, PR review feedback, complexity analysis and walkthrough videos. When a person accepts the result, the agents land the PR.

The repo gives you two routes. The first is a written spec (SPEC.md) that you can hand to a coding agent to build Symphony in any language. The second is an experimental reference implementation in Elixir. The README says it works best in codebases that already follow OpenAI's harness engineering approach, and it calls the project a low-key engineering preview for trusted environments.

Read more on interesting repos · GitHub

Coding agents like Claude Code or Codex normally talk to one company's models. This project sits in the middle as a local proxy. You add an API key for a provider such as NVIDIA NIM, OpenRouter or Groq, pick a model in a web Admin page, and the agent's requests go through the proxy to that model.

You install it with a script, start the server, then launch agents through wrappers such as fcc-claude, fcc-codex, fcc-pi or fcc-aider. You can also set an ordered list of fallback models, so if one provider fails after retries the proxy tries the next without making you restart the turn.

The README says streaming, tool use, images and thinking blocks keep working, and that the Opus, Sonnet and Haiku slots can be routed to different models. It also describes a browser UI for Codex sessions, voice notes through Whisper, and Discord or Telegram access. Free-tier limits belong to each provider and can change. The project says it is not affiliated with Anthropic, and the GitHub license field is unclear (the badge says AGPL v3), so check the license before relying on it.

Read more on interesting repos · GitHub

Coding agents like Claude Code and Codex mostly live in a terminal or in their own separate apps. T3 Code puts one interface on top of them. It runs a server on your computer, and you talk to your agents through a web app, an Electron desktop app, or a phone app.

It does not replace the agents or sell you access to them. You install and sign in to each agent's own tool first, and T3 Code controls whatever is already set up, so your existing subscriptions are used.

The authors say they were inspired by the Codex desktop app, Conductor, Claude Desktop and Cursor Glass, but wanted something fast, usable remotely, and fully open so anyone can fork it. The README is frank that the project is very early and bugs are expected. It is also mostly not accepting outside contributions.

Read more on interesting repos · GitHub

Coding agents often find the right files by trial and error, or you paste big chunks of a project into the prompt. Both cost tokens and time on large codebases. Claude Context gives the agent a search tool that finds code by what it does, not only by matching keywords.

It runs as an MCP server. You ask your agent to index the project. The code is turned into embeddings with an OpenAI embedding model and stored in a Milvus-compatible vector database, such as Zilliz Cloud. When you ask for something like 'functions that handle user authentication', the agent calls the search tool and gets back only the matching code.

The README contrasts this with loading whole directories into context on every request. It works with many clients besides Claude Code, including Codex CLI, Gemini CLI, Cursor, Windsurf and Cline. The default setup needs two outside accounts: an OpenAI key for embeddings and a Zilliz Cloud key for the database.

Read more on interesting repos · GitHub

OpenCode is an AI coding agent. You talk to it in a terminal interface, and it helps with development work such as reading code, planning changes and running commands. A desktop app is also available as a beta.

It ships with two built-in agents you switch between with the Tab key. The build agent has full access and is the default. The plan agent is read-only. It denies file edits by default and asks before running bash commands, which suits exploring code you don't know yet.

There is also a general subagent for complex searches and multistep tasks. OpenCode uses it internally, and you can call it with @general in a message. The README doesn't compare OpenCode with other coding agents. It leaves configuration, such as model providers, to the separate docs site.

Read more on interesting repos · GitHub

Coding agents run out of context when a task is large. Ralph works around this by splitting a feature into small user stories and starting a fresh agent instance for each one. It follows Geoffrey Huntley's Ralph pattern.

You write a product requirements document (PRD) with a skill, then convert it to prd.json. A bash script, ralph.sh, picks the highest-priority story that hasn't passed and asks the agent to implement it. It then runs typecheck and tests. If the checks pass, it commits and marks the story done.

Because every iteration starts with clean context, memory lives in three places: git history, a progress.txt file of learnings, and prd.json. Ralph also updates AGENTS.md files so later runs, and human developers, pick up the patterns it found. It works with Amp (the default) or Claude Code.

Read more on interesting repos · GitHub

Warp started as a modern terminal and has grown into what its team calls an agentic development environment. You type shell commands as usual, and you can also hand tasks to a coding agent from the same window.

You have two ways to use agents. You can use the one built into Warp, or you can bring a command-line agent you already like, such as Claude Code, Codex or Gemini CLI. The client code is open source in this repository. The UI framework crates are MIT-licensed, and the rest is AGPL v3.

The repository itself is run with Warp Factories, which are agents that triage issues, write specs, implement changes and review pull requests. A public dashboard at build.warp.dev shows that work. The README says little about how the built-in agent works, so check the docs for details.

Read more on interesting repos · GitHub

Codex CLI is a coding agent you run from the command line. You start it with the codex command inside your project, and it works on your computer rather than in a hosted service.

The README is short on technical detail. It covers installing, signing in and where to find the docs. For how the agent works, the full docs on developers.openai.com are the place to look.

OpenAI offers Codex in other forms too: an IDE extension for VS Code, Cursor and Windsurf, a desktop app launched with codex app, and a cloud agent called Codex Web. The CLI is the terminal option in that set. It is written in Rust and licensed under Apache-2.0.

Read more on interesting repos · GitHub