Open-Source AI Radar: 19 Rising GitHub Repos (Sept 2026)

The third edition of the radar tracks 19 rising repositories that were all created between mid-July and mid-September 2026. Same idea as before: niche projects that are growing fast right now, not the household names every list already covers. This edition covers eight clusters: local inference, open voice, agent memory, computer-use, MCP servers, agent frameworks, coding-agent tooling, and media and design.

Two patterns stood out while researching it. First, local inference on Apple Silicon is getting creative: three of the projects stream model weights from SSD or across devices instead of loading everything into RAM. Second, agent memory is fragmenting into very different designs, from plain Markdown files to a Datalog engine with provenance tracking. Both are areas where a hosted product does not yet answer the question for you, which is exactly what a radar is for.

How this edition was built#

The shortlist came from the GitHub Search API: repositories created after July 10, 2026 with more than 150 stars and AI-related topics (ai, llm, mcp, agents, ai-agents, claude-code). That returned 365 new candidates. A fork-to-star sanity check and a manual pass then cut it to 20 for verification. We deliberately skipped:

• Flagship releases from big vendors, even when they trend (a new DeepSeek harness, a Google Android automation project). They do not need a radar. Niche research or incubation repos from teams inside larger companies stay in: this edition has two, LongHorizon Harness from Alibaba's AMap-ML team and ripwire from Red Hat's emerging-technologies group.
• Lists, books, tutorials and prompt collections. Useful, but not tools.
• Plugins that only make sense inside one large platform.
• Claims that fail a plausibility check, for example running a multi-trillion-parameter model on a single CPU in a few gigabytes of RAM.

Each of the 20 was then checked against its README, commit history, releases, LICENSE file and homepage. One was excluded: its own maintainer marks the repository as migrated to a successor project, so listing it as "rising" would mislead. The other 19 made it in.

Star and fork counts are as shown on GitHub on September 23, 2026 and are not independently audited. Performance figures attributed to a project are that project's own claims, not our measurements.

The three license tiers#

"All OSI-open" is not the whole story, so here are the catches worth knowing before you build on something:

• Open code, proprietary engine. classifier-dev and TypeSafe Computer Use are MIT-licensed, but the classification model both rely on is a proprietary hosted service.
• Dual licensing. Penecho and Tel-Agent are AGPL-3.0 with a separate commercial license from the maintainers. Penecho also requires a contributor license agreement.
• Commercial upsell and defaults. Phone Harness has telemetry on by default and points to a paid cloud version throughout its README.
• Security surface. x64dbg MCP Server exposes a full debugger over the network. Keep it on localhost and read its security notes before enabling it.

Local inference and "what runs on my machine"

TurboFieldfare (drumih/TurboFieldfare) - 6.8k stars

A native Swift and Metal inference engine for Apple Silicon that keeps only a 1.35 GB shared core and the FP16 KV cache in memory, streaming the routed mixture-of-experts weights of Gemma 4 26B from SSD on demand instead of loading the full 14.3 GB checkpoint. Prefill runs in 128-token chunks, reads are bounded and parallel, and the installer streams weights directly from Hugging Face.

Pros

• Native Swift/Metal implementation with a real Metal-kernel streaming runtime, not a Python wrapper
• Apache-2.0 on the code, daily commits and a fast release cadence (0.4 to 0.9 in about a month)
• Ships both a CLI and an OpenAI-compatible server, plus a native Mac app

Cons

• arm64 / Apple Silicon and macOS 26+ only - no Linux, Windows or Intel Macs
• Pre-1.0 (v0.9.0); the streamed model weights follow Google's own Gemma license, separate from the Apache-2.0 code
• Throughput claims (5-6 tok/s on an 8 GB M2, 31-35 tok/s on a 24 GB M5 Pro) are the project's own measurements, not independently reproduced

License: Apache-2.0. When it is interesting: Apple Silicon owners with tight RAM who want to run a 26B Gemma model without buying a bigger Mac. When it is too early: Any non-Apple hardware, or if you need a finished v1.0 with a stable API.

Slotstream (carloslfu/Slotstream) - 391 stars

A native Swift program built on Apple's MLX and Metal that runs Qwen3.8-Flash-Next, a 105 GB mixture-of-experts model with 125B parameters, on Macs with only 16 to 64 GB of unified memory. Shared weights stay in memory while needed experts are read from SSD into a slot-based cache, with automatic memory planning and expert lookahead prediction. It exposes OpenAI- and Ollama-compatible APIs and runs fully offline, with no Python and no cloud account.

Pros

• Detailed, reproducible hardware measurements (MEASUREMENTS.md, HARDWARE.md) instead of just headline numbers
• MIT on the code; native Swift/MLX/Metal with no Python runtime, OpenAI- and Ollama-compatible endpoints
• Active daily development with a real issue tracker (hardware reports, bug fixes, feature requests)

Cons

• Apple Silicon / macOS 14+ only
• Model weights (Qwen3.8-Flash-Next) carry the separate Qwen community license, not MIT
• The same team is building a commercial Mac app (Sevra, at sevrahq.com) on top of this engine - worth watching how the open engine and paid app diverge over time
• Pre-1.0 (v0.2.x), and a reported issue notes long re-prefills can make the server exit silently

License: Code is MIT; the Qwen3.8-Flash-Next model weights it targets carry the separate Qwen community license. When it is interesting: Apple Silicon users with 16-64 GB RAM who want a large MoE model that would not otherwise fit. When it is too early: Non-Apple hardware, or production reliability given the still-early 0.2.x version and reported stability issues.

SwarmLLM (nehanth/SwarmLLM) - 435 stars

A JavaScript/WebGPU engine that distributes an LLM's layers across multiple devices, each peer holding a slice of layers, passing only a roughly 10 KB activation vector to the next device over WebRTC. It runs a custom WGSL kernel stack (around 50 kernels) with 4-bit quantization and speculative decoding entirely in the browser, with no server and no installation.

Pros

• Genuine from-scratch engine: custom WGSL kernels, a GGUF parser and a WebRTC mesh protocol, backed by a golden-test suite the project says gates every optimization
• No install and no server - runs in the browser, pooling idle devices (laptop + phone) to hold a model neither could run alone
• MIT, active daily commits with structured, labelled issues (P1/P2, milestones)

Cons

• Very early: one release (v0.2.0), and the 2048-token context window is explicitly flagged by the project's own issue tracker as too short
• Peer-to-peer WebRTC inference depends on the reliability and bandwidth of every participating device - the project's own issues note dropped worker tabs under memory pressure and backgrounding
• Throughput numbers (9-16 tok/s depending on speculative decoding, a demo of 10.7 tok/s across a MacBook and iPhone) are the project's own benchmarks on specific hardware, not independently reproduced

License: MIT. When it is interesting: Experiments in pooling multiple personal devices to run a model too large for any one of them, entirely in the browser. When it is too early: Anything needing a stable API, long context, or reliable production throughput - this is pre-1.0 and the maintainers' own issues describe real reliability gaps.

Open voice and text-to-speech

Tel-Agent (dpro-at/Tel-Agent) - 1.0k stars

A self-hosted gateway that routes incoming SIP calls to a human, blocks them, or hands them to an AI agent that can transfer calls, take messages, check calendars and call HTTP endpoints, with every interaction recorded and transcribed. The same agent configuration also handles 24+ other channels (web chat, SMS, email, WhatsApp, Telegram, Messenger, Instagram, Discord, Slack) using credentials you supply yourself, built on Python/LiveKit Agents, FastAPI, Next.js/React, SQLite or PostgreSQL, Redis and Caddy.

Pros

• Backed by a registered company (Dpro GmbH, Vienna, Austria) with a real dual-license model, not an anonymous side project
• Broad channel coverage (phone via SIP plus 24+ messaging platforms) behind one agent, with real integrations rather than stubs
• Docker images, five interface languages, and an active, labelled issue tracker with ongoing channel work (Viber, Signal, Matrix, IRC in progress)

Cons

• Alpha status per the project's own badge; only two pre-releases (v0.1.0, v0.1.1) as of writing
• AGPL-3.0 requires publishing modifications for any network-service deployment - commercial or closed use needs Dpro's paid license
• The sub-800ms latency target is the project's own goal/claim for its pipeline, not an independently measured guarantee

License: AGPL-3.0: network use counts as distribution, so a modified version run as a service must be published under AGPL too, unless you buy Dpro GmbH's commercial license. When it is interesting: Teams wanting a self-hosted, own-keys alternative to closed voice-agent platforms across both telephony and chat channels. When it is too early: Production deployments needing a finished v1.0, or any closed/commercial redistribution without buying the Dpro license.

Agent memory and code knowledge

VoiceMem (xzf-thu/VoiceMem) - 2.2k stars

A memory framework purpose-built for voice agents. A 'left brain' organizes factual information through schemas and entities for precise retrieval, while a 'right brain' independently tracks emotions, personality traits and relationships. A streaming pipeline handles audio segmentation, transcription and memory extraction while the conversation is still happening, using FunASR/sherpa-onnx for speech recognition, 3D-Speaker for speaker verification and multilingual-e5 embeddings, injecting only the top-ranked memories into the model's context.

Pros

• Apache-2.0, real streaming pipeline (ASR, speaker verification, memory extraction) rather than just a prompt wrapper
• Backed by a technical report on arXiv and a reproducible evaluation suite in the repo (LoCoMo, PersonaMem)
• Purpose-built for voice, not text-chat memory retrofitted for audio - separates factual and emotional memory explicitly

Cons

• Very young: first release v0.0.1 on September 1, 2026, two releases total
• Headline comparisons against Mem0 (91.2% vs 61.68% on LoCoMo, 134ms vs 1,440ms response time) are the project's own benchmark, not independently verified
• Open issues report emotion labels and personality traits defaulting to Chinese even for English-speaking users - a real localization gap to check before non-Chinese deployments

License: Apache-2.0. When it is interesting: Voice-agent builders who need persistent, emotion-aware memory across sessions and are comfortable running a research-stage project. When it is too early: Production voice products needing stable APIs or verified-language behavior outside Chinese/English.

agent-memory (tigerless-labs/agent-memory) - 964 stars

A memory runtime where plain markdown files in one store are the single source of truth, and a local SQLite index beside them is a disposable, rebuildable cache. Recall is local and ranked and answers with paths rather than pasted text; writes fire automatically at conversation boundaries; a sleep-time pass consolidates and forgets on its own clock, with deletions arriving only as proposals to confirm. Claude Code, Codex CLI and anything else that can run a shell command share the same store, with no API key required.

Pros

• Markdown files stay greppable, git-able and portable off the system; the SQLite index is a disposable, rebuildable cache (`rm -rf .index/ && mem rebuild` is enforced by a test to lose nothing)
• A real Manage layer with authority tiers: an unattended sleep pass may add and update, but deletion only ever arrives as a proposal you confirm
• No LLM client inside the library itself, so there is no API key to configure; judgment is borrowed from the host agent's own CLI, and every write stays visible in that host's transcript

Cons

• Only three weeks old (created 2026-09-01) and not on PyPI yet - install is git clone plus uv sync from a checkout
• The parent org (tigerless-labs) has shipped a new tool roughly every two to three weeks through 2026, several reaching hundreds to thousands of stars within weeks - a launch cadence worth watching, even though the commit history includes real externally authored PRs fixing actual bugs
• The 'proof it works' benchmark is the project's own 120-episode LongMemEval-S study with a bounded haystack, explicitly flagged by the project itself as not comparable to published LongMemEval scores

License: MIT. When it is interesting: Teams standardizing memory across Claude Code and Codex CLI who want a plain-markdown store they can inspect, grep and migrate off at any time. When it is too early: Anyone who needs a packaged release, a stable API, or independent verification of the retrieval-accuracy claims.

deja-vu (vshulcz/deja-vu) - 926 stars

deja-vu indexes the session files Claude Code, Codex, Cursor and dozens of other coding agents already write to local disk, and hands the right one back to whichever agent asks, regardless of which agent originally wrote it. There is no capture step; the transcripts themselves are the memory. Credentials are redacted at index time, and recall fires automatically at session start, before a tool runs, and after a failure. A single Go binary does this fully offline with millisecond-range lookups.

Pros

• Very broad harness support (34 coding agents matrixed in the README, from Claude Code and Codex to aider and Zed) with per-harness auto-recall, not just a generic plugin claim
• No capture step and no LLM or embedding key needed for the core path; it parses the JSONL/SQLite session files agents already write, so it starts full with months of pre-install history
• Very active: 33 contributors, near-weekly releases (v0.21.0 at time of writing), credential redaction at index time, and an explicit security-model document

Cons

• Headline numbers (88.1% hit@1 LongMemEval-S, 70.5% hit@1 LoCoMo) come from the project's own benchmark harness, reproducible from the repo but not independently verified
• Windows is described as builds-exist-and-CI-runs-there, while macOS and Linux are called the battle-tested paths, a real caveat for Windows users
• Optional semantic recall sends redacted, truncated indexed text to whatever embedding endpoint you configure (local Ollama/LM Studio by default, or a cloud key if set), worth checking against your own privacy bar even with local-first defaults

License: MIT. When it is interesting: Developers who switch between multiple coding agents on one machine and want prior decisions surfaced automatically, without standing up a memory service. When it is too early: Windows-first workflows, or anyone who wants independently benchmarked retrieval numbers rather than the project's own reproducible harness.

Lemmalog (JordyZomer/Lemmalog) - 317 stars

A Rust Datalog engine built on the thesis that an agent's memory should be a deductive database: base facts are asserted at an LLM extraction boundary, and rules mechanically derive closures, temporal projections and contradiction candidates from them, with every fact carrying provenance back to its source episode. An MCP server with twelve tools (observe, query, why, what_if and more) plugs the engine into Claude Code or Kimi CLI, and a hybrid BM25-plus-entity-graph retrieval layer assembles budgeted context instead of dumping the whole store.

Pros

• A genuinely different architectural bet: facts are asserted and rules derive closures, temporal projections and contradiction candidates deterministically, with why() proof trees back to source episodes rather than similarity search
• Unusually rigorous validation for a three-week-old project: 450 random programs checked against a brute-force fixpoint oracle, incremental-vs-single-shot equivalence checks, and 2,000-case parser fuzzing
• Runs its own numbers on two standardized public leaderboards (ProsusAI MemEval's LongMemEval split and LoCoMo) and reports a 2nd-of-10 and mid-pack placement rather than only citing wins

Cons

• Very early: created 2026-08-27, no tagged release yet, and the maintainer's own README documents engine bugs found and fixed during development
• Fact extraction still depends entirely on an external LLM call to turn prose into triples; the Datalog engine itself has no language understanding, so extraction quality is a hard ceiling on everything downstream
• Small team so far (5 contributors, led solo by Jordy Zomer with occasional outside PRs) and no CI badge or release process visible yet

License: MIT. When it is interesting: Agent-memory setups where deterministic, auditable reasoning over facts (temporal ordering, contradiction detection, multi-hop queries) matters more than semantic recall. When it is too early: Production use before a first tagged release, or if you need a memory system that doesn't depend on an LLM extraction step.

Computer-use and autonomous agents

typesafe-computer-use (awlevin/typesafe-computer-use) - 853 stars

A computer-use agent that reads the screen deterministically via OCR and the macOS accessibility tree, then asks TypeSafe's small classifier for the next action instead of a frontier vision model, only calling a writer model (Claude by default, any OpenAI/Anthropic-compatible endpoint otherwise) when a step genuinely needs free text or a final read of the screen. It drives a real mouse and keyboard on macOS, with experimental Windows support via UI Automation.

Pros

• Genuine architecture, not a wrapper: OCR plus the accessibility tree feed a fast classifier, with a writer model called only when free text is needed
• MIT-licensed, developed daily with a real CI pipeline and a scenario-based test suite (40+ scripted scenarios)
• Any OpenAI- or Anthropic-compatible endpoint can serve as the writer model, including local ones (LM Studio, Ollama, vLLM, a LiteLLM proxy)

Cons

• Its core cost/speed advantage depends on a mandatory paid third-party API (TypeSafe's classifier) - the open-source repo alone does not replicate the cited savings
• One week old at the time of writing (created 2026-09-16); a 0.x beta with rapid, possibly unstable daily changes
• The cost/speed comparison table against Claude Opus 5 is the project's own benchmark, not an independently reproduced result

License: MIT. When it is interesting: You want a cheap, fast, OpenAI/Anthropic-agnostic computer-use loop on macOS and are willing to pay for the TypeSafe classifier. When it is too early: You need a fully self-hosted, no-external-dependency tool, or stability beyond a week-old 0.x beta.

phone-harness (ShawnPana/phone-harness) - 3.0k stars

Connects Claude Code, Codex or any agent to a real phone: iPhone through the Mac's iPhone Mirroring window, Android over adb from macOS, Linux or Windows. The agent reads the screen (screenshots, OCR), taps, types and scrolls through the same helper functions regardless of platform, with no jailbreak, no Xcode and nothing installed on the phone itself. A paid 'Phone Harness Cloud' add-on rents Android phones by the minute for users without a spare device.

Pros

• Real, working automation across both iPhone (via iPhone Mirroring) and Android (via adb), with detailed handling of edge cases like background scrolling and focus stealing
• MIT-licensed core with no jailbreak, SDK or on-device install required
• Active development with three shipped releases (0.1.0 to 0.3.0) over about six weeks and 40 open issues showing real usage

Cons

• Effectively a single-maintainer project (97 of roughly 98 commits from one author)
• Telemetry (PostHog) is on by default, opt-out only, and the README pushes a paid 'Phone Harness Cloud' upsell with UTM-tagged links throughout
• Full iPhone control depends on macOS's iPhone Mirroring feature, so it only works from a Mac; Android control works from macOS, Linux or Windows

License: MIT. When it is interesting: You want an agent to operate a real phone (app testing, purchases, form-filling) without jailbreaking or installing anything on the device. When it is too early: You need multi-maintainer governance, or want telemetry off by default rather than opt-out.

LongHorizon-Harness (AMAP-ML/LongHorizon-Harness) - 1.6k stars

A 'loop engineering' system from Alibaba's AMap ML team that wraps an existing coding agent (Claude Code, Codex, OpenCode or DeepSeek Harness) in a plan-act-verify-checkpoint loop: it re-derives the goal and verified state each round, executes a bounded step with a fresh context window, checks the real result on the desktop or in the terminal, and either checkpoints progress or feeds failure evidence into the next round. It targets both GUI desktop apps and the terminal, and reports results on named public benchmarks (WeaveBench, OSWorld 2.0, Terminal-Bench 2.1) backed by an arXiv paper.

Pros

• Backed by an established org (Alibaba's AMap ML team) with an arXiv paper and results reported on named public benchmarks rather than a private one
• Multi-backend by design: works with Claude Code, Codex, OpenCode and DeepSeek Harness rather than locking you into one agent
• 9 real contributors and 8 releases (v0.1.2 to v0.1.7) in its first three weeks show a genuine development burst, not a single commit dump

Cons

• No commits or releases since 2026-08-20, over a month stale at the time of writing, despite 40 open issues sitting unaddressed
• Benchmark gains on WeaveBench, OSWorld 2.0 and Terminal-Bench 2.1 are the project's own reported numbers, not independently reproduced
• It orchestrates an existing agent rather than replacing its judgment, so output quality is still bounded by whichever backend model you point it at

License: MIT. When it is interesting: You already use Claude Code, Codex or OpenCode and want them to keep working autonomously on long, multi-hour desktop/CLI tasks with checkpointed recovery. When it is too early: You need continuously maintained tooling - the month-plus of silence since the last push is a real caveat against the strong initial burst.

MCP servers for coding agents

x64dbg-MCP Server (duty1g/x64dbg-MCP Server) - 2.0k stars

A native x64dbg plugin, written in Zig with zero runtime dependencies, that exposes the debugger's full functionality (84 MCP tools covering breakpoints, stepping, memory, registers, modules, pattern scanning, PE analysis and more) over an MCP-compatible HTTP/SSE server so any MCP client can drive a live debugging session. It targets reverse engineering, security research and malware analysis workflows, and ships single-binary builds for both x32 and x64.

Pros

• Zero-dependency native Zig plugin, cross-compiles to a single binary for both x32 and x64 from any host
• Broad, genuinely deep tool coverage (84 MCP tools, 22 event callbacks) for real debugger control, not a thin wrapper
• The maintainer has shipped real security hardening across releases: Bearer auth was made mandatory and a pre-auth DoS was fixed in v1.2

Cons

• Gives full remote code execution, memory read/write and process control over HTTP - the project's own disclaimer warns not to expose it to untrusted networks, and traffic is unencrypted HTTP even with auth
• The README's default-port table still lists 0.0.0.0 despite a changelog entry describing a default-to-loopback fix in v1.2 - verify your actual bind address before trusting it's local-only
• Small team (3 contributors, effectively one maintainer) and only about one month of history at the time of writing

License: MIT. When it is interesting: You want to control x64dbg from an AI assistant for legitimate reverse engineering, debugging or authorized malware analysis, and can keep the server off untrusted networks. When it is too early: You need the server reachable outside a trusted host, or want an independently security-audited, network-exposed debugger.

Agent frameworks and runtimes

reef (human-agent-society/reef) - 4.2k stars

An open-source infrastructure platform connecting agent inference, feedback collection, model training and versioned artifact delivery, so agents improve continually without manual retraining cycles. It runs a four-stage cycle (Serve, Observe, Grow, Commit), supports both model-weight training and harness-only optimization (the GPU-free 'Reefine' recipe), and plugs into existing vLLM or SGLang inference.

Pros

• Full four-stage pipeline (serve, observe, grow, commit) rather than a single training script, with a GPU-free harness-optimization mode (Reefine) alongside full weight training
• Real engineering signals: 10+ active contributors, commits through the day of this check, benchmarks published against AIME 2025, Terminal-Bench and other suites (the project's own numbers)
• Apache-2.0 on code, plugs into existing vLLM/SGLang serving instead of requiring a new inference stack

Cons

• Very young: repo created 2026-08-31, first tagged release (v0.1.0) shipped the same day this was checked - no track record yet despite the fast-growing star count
• LICENSE file's copyright holder (Zhipu AI) does not match the human-agent-society org that publishes it - worth clarifying before relying on it commercially
• Benchmark results (AIME 2025, IMOAnswerBench, CEO-Bench, Terminal-Bench) are the project's own reported figures, not independently reproduced

License: Apache-2.0 per the repo badges and README - but the LICENSE file's copyright line reads 'Copyright 2025 Zhipu AI', not the human-agent-society org, an inconsistency worth noting even though the terms themselves are unambiguous Apache-2.0. When it is interesting: Teams building agents that need to learn from production feedback without hand-rolling the plumbing between serving, feedback and training. When it is too early: Production use before the license anomaly is clarified, or if you need a project with more than three weeks of history.

Coding agents and context efficiency

classifier.dev (mrmps/classifier.dev) - 412 stars

A single Cloudflare Worker that takes text and labels and returns a label with a calibrated confidence, no account or API key needed, up to 1,000 texts per request. Classification is answered by TypeSafe's Jev, a dedicated decision model, with an LLM fallback chain and a 'smart' tier that re-asks low-confidence cases. The same logic ships as a CLI, an MCP tool, and an agent skill served straight from the domain, with Durable-Object rate limiting and privacy-preserving analytics.

Pros

• No account or API key needed for the free tier - curl https://classifier.dev/spam,not+spam/... just works, a real barrier removed for agent tool-use
• Substantial original engineering beyond a thin wrapper: Durable-Object-based per-IP rate limiting (with two rejected approaches documented, including a Cloudflare native binding that silently failed to decrement), keyed-pseudonym privacy for analytics, and a CI pipeline that runs a live classification against the deployed Worker before a deploy is considered successful
• Self-hostable on your own Cloudflare account with your own provider keys, not only usable as the hosted classifier.dev service

Cons

• The core classification model (TypeSafe's Jev) is a closed, proprietary third-party API - the MIT license covers the Worker/CLI/routing code, not the model doing the classifying
• Solo-maintained in practice (162 of roughly 169 commits from one author) and only six weeks old (created 2026-08-13), with just two total GitHub issues logged so far
• Accuracy and speed numbers (confidence calibration, F1 comparisons against LLM cascades) are the project's own /benchmark page, not independently reproduced

License: MIT covers the Worker, CLI and MCP server. Classification itself is answered by TypeSafe's proprietary Jev API, with an OpenRouter/AI-Gateway LLM fallback chain: no open classification model ships with this repo, and self-hosting still means depending on that closed backend. When it is interesting: Coding agents or pipelines that need to cheaply triage or filter large batches of text (search results, feedback, tickets) before spending tokens on a full model. When it is too early: If you need the classification model itself to be open and self-hostable, not just the routing layer around a closed one.

ripwire (redhat-et/ripwire) - 2.3k stars

A single-binary CLI and MCP server, built by Red Hat's Emerging Technologies group, that generates ranked call graphs, impact analysis and a code-quality panel across 24+ languages. It markets itself as 'the ripgrep of AI context': instead of an agent grepping and reading whole files cold, ripwire hands it a structured map of what matters, who calls what, and which tests are affected by a change.

Pros

• Backed by an official Red Hat org (redhat-et, 178 repos, ripwire is one of its pinned projects), not an anonymous account - real accountability behind the project
• Zero runtime dependencies, single offline-capable binary, 24+ languages via vendored tree-sitter grammars
• Ships as ready-made skills for Claude Code, Codex, Cursor, Windsurf and Gemini, plus MCP and JSON/HTML output

Cons

• Token- and speed-savings figures (e.g. '5.0% of tokens vs grep-and-read', '58.3% strict file@10') are the project's own benchmark, not third-party verified
• Pre-1.0 (v0.6.2), weekly point releases suggest the interface and flags are still moving
• C++23 toolchain and CMake 3.24+ needed to build from source, even though prebuilt binaries exist for macOS/Linux

License: Apache-2.0. When it is interesting: Coding-agent setups that burn real tokens re-reading files, and want a structured map of a codebase instead. When it is too early: If you need a stable CLI surface - flags and output formats are still changing release to release.

agentacct (mikehasa/agentacct) - 753 stars

A local-first tool that reads coding-agent session logs (Claude Code, Codex, OpenCode, Hermes) and turns them into 'work receipts': which tools ran, which files changed, which tests passed, how long it took and what it cost. It tags every claim with an evidence tier (reported, verified, observed) instead of trusting an agent's own summary, and ships a dashboard, terminal UI and local API, all with no cloud sync or telemetry.

Pros

• Evidence tiers (reported vs. verified vs. observed) instead of taking an agent's self-report at face value
• Genuinely local: reads session files on disk only, no account, no cloud sync, no API keys stored
• Fast release cadence (0.11.2 as of this check) with an active small-team commit pattern

Cons

• Multi-agent support depends on each agent's session-log format staying stable; Hermes/OpenCode coverage is newer and less battle-tested than the Claude Code integration
• MIT, fully OSI-open, but still 0.x (v0.11.2) - the work-receipt data schema could still change between releases
• Small maintainer base (effectively one primary author plus a close collaborator) - bus-factor risk if development stalls

License: MIT. When it is interesting: Anyone running multiple coding agents who wants a single, verifiable log of what they actually did and what it cost. When it is too early: Teams that need a stable, versioned data schema today rather than a fast-moving 0.x tool.

Media, design and video

PenEcho (penecho/PenEcho) - 2.4k stars

A canvas app for spatial work with AI: combine handwriting, equations, diagrams and interactive HTML widgets on one surface, while an AI agent (its own built-in one, or Codex, Claude Code or Kimi CLI connected over MCP) reads and edits the same canvas. A local server or desktop app runs the workspace, professional architecture, sequence and workflow diagrams get automatic layout, and handwritten feedback flows back into the agent's next revision.

Pros

• Real, polished product: native Windows/macOS desktop builds, an npm-installable local server, and a steady release cadence (v0.7.2 in late July to v1.3.3 by September, with a dedicated CHANGELOG)
• MCP integration is two-way in practice - an agent can read the canvas, patch diagrams and receive your handwritten feedback for its next revision, not just push content one way
• AGPL-3.0 is a genuine OSI-open copyleft license, not a source-available fauxpen license, with the professional-diagram renderer built on an acknowledged MIT-licensed upstream (Archify)

Cons

• AGPL-3.0 plus a separate commercial license and a mandatory Contributor License Agreement is a classic open-core structure - honest, but it means the company can relicense contributions and sell around the copyleft obligation
• Brings no model of its own: quality depends entirely on whichever model you connect (PenEcho Cloud credits, your own OpenAI/Anthropic-compatible key, or an authenticated Codex/Claude/Kimi CLI)
• Effectively a two-person project (43 of 44 commits from the maintainer) despite the 2,392 stars and 314 forks, and the model-recommendation table in the README is already a snapshot that will age quickly

License: AGPL-3.0-only, an OSI-open copyleft license, paired with a separate commercial license (COMMERCIAL-LICENSE.md) and a mandatory Contributor License Agreement: a standard open-core structure, worth reading before a company-scale SaaS deployment. When it is interesting: Visual, spatial thinking work with an AI agent - architecture and workflow diagrams, annotated feedback loops - where a chat window is the wrong interface. When it is too early: Teams that need an unrestricted commercial SaaS license without engaging AGPL's obligations, or anyone who wants a bundled model rather than bringing their own.

OpenChatCut (0xsline/OpenChatCut) - 2.0k stars

A desktop video editor (Electron, React 19, TypeScript, Vite) that pairs a multitrack timeline with AI agents you talk to - the agent edits real tracks, clips, transitions and captions rather than generating a one-shot, unchangeable video. It supports transcript-driven editing, AI-generated images/video/speech/music, and exposes an MCP server so external coding agents (Codex, Claude Code) can drive the project directly.

Pros

• Keeps an editable project (real timeline, clips, transitions) instead of an immutable rendered video - a real architectural difference from one-shot AI video tools
• Finished desktop app with signed installers for macOS, Windows and Linux, not just a script
• MCP server lets coding agents (Codex, Claude Code) drive edits programmatically, on top of its own conversational agent

Cons

• AGPL-3.0: strong copyleft, meaning a hosted/SaaS fork must generally release its source too - check this before building a commercial service on top
• AI generation features (images, speech, music) depend on external provider API keys (OpenAI, Anthropic, Gemini, Fal.ai) - not a fully self-contained local pipeline
• No performance or quality benchmarks published - claims are architectural, not measured

License: AGPL-3.0. When it is interesting: Teams that want AI-assisted video editing but need the result to stay a fully editable project, not a rendered dead end. When it is too early: Anyone building a hosted product on top, given the AGPL-3.0 copyleft terms.

CozyClay (nomadamas/CozyClay) - 717 stars

A browser-based previsualization tool for film and animation: block a scene in real-time 3D, pose characters, edit camera moves on a timeline, then export keyframe packs, depth/normal passes, storyboards or OTIO cut lists - or hand the shot straight to an AI video model (Seedance, Kling, Veo, MiniMax). It also does motion capture from video/photos and exposes an MCP server and CLI for agent-driven control.

Pros

• Bridges traditional previs (blocking, camera, cast posing) with AI video generation instead of replacing one with the other
• Runs via `npx cozyclay` with a prebuilt dist - no build step to get started
• MCP server and CLI (`cclay live`) allow agent-driven scene control alongside the manual 3D editor

Cons

• Effectively a single-maintainer project (nearly all commits from one author) - bus-factor risk
• Motion capture and some pose-generation features depend on GPU-based bridges (Kimodo, GVHMR, NVIDIA ARDY) that are not part of the core browser app
• AGPL-3.0-or-later: strong copyleft, relevant if you build a hosted service on top

License: AGPL-3.0-or-later. When it is interesting: Small film/animation teams wanting a free, agent-friendly previs step before AI video generation. When it is too early: Production pipelines that need more than one maintainer's bus factor, or a permissive license for a hosted product.

Previous editions: June 2026 and July 2026. The full, filterable directory of every repo we have tracked lives at /open-source.