580 tools and products — trending open source, and what gets used in AI and other work.
Monid is an API and connector framework for AI agents, providing one base URL and key for discovering and calling tools across providers. Its catalog covers services such as web search, scraping, enrichment, social data, reviews, market data, and media generation. The discover operation ranks candidate endpoints across providers for a task and returns pricing, live health, observed p50 and p95 latency, and alternative endpoint hints. Providers and endpoints are defined declaratively with authentication, metadata, request schemas, timeouts, and usage models. The engine validates inputs, builds and sends provider requests, settles usage against the raw response envelope, maps outputs, and validates the final result; provider errors are returned as data and settle at zero usage. Connectors run locally with vendor credentials, in fixture-based offline tests, or on the hosted platform with credentials injected into the transport. The open-source repository requires Deno 2.x and includes catalog, compilation, execution, recording, and replay-test tooling. It is licensed under the MIT License.
Mercury is Inception’s family of diffusion-based language models for generating text and code. Unlike autoregressive language models that generate tokens sequentially, Mercury generates discrete tokens in parallel to improve inference scaling, hardware utilization on standard GPUs, and latency. The models target production serving and latency-sensitive applications such as voice agents, with quality comparable to speed-optimized models from frontier laboratories while generating outputs significantly faster.
Omnient is an AI harness that multiplexes between different agent harnesses to provide cost and execution control.
Lakebase is a Postgres database discussed as infrastructure that AI agents can select and use. It is described as supporting rapid provisioning and database branching.
Cua is an open-source computer-use platform from Cua AI, Inc. that provides desktop automation, isolated cloud desktops, local virtual machines, and benchmarks for AI agents. Its Cua Fleets provision Linux desktops whose capacity is managed in pools; agents use the Sandbox SDK to run commands, capture screenshots, and interact with applications. Cua Driver exposes tools for inspecting and operating native desktop applications and browsers on macOS, Windows, and Linux through a CLI, MCP, or typed SDKs, with background delivery where supported. Lume creates and manages local macOS and Linux virtual machines on Apple Silicon using Apple's Virtualization framework. Cua Bench builds computer-use tasks, evaluates agents, and exports trajectories for training, including simulated tasks that do not require a VM, Docker, or a model API key. The project is MIT-licensed, while some third-party components have separate licenses.
Jev Review is a local-first MCP plugin for continuous software-quality review by AI coding agents, powered by Jev. It runs as a local Node.js server over MCP stdio and exposes a focused `jev_review` tool: an agent submits a task, focused diff, selected files, or repository context, and Jev returns structured per-dimension scores and confidence values for areas such as correctness, complexity, readability, modularity, changeability, testing, reliability, security, and documentation. When a previous evaluation is supplied, the plugin reports metric deltas, improvements, regressions, and weak dimensions rather than producing a blended overall score or prose diagnosis; the coding agent remains responsible for identifying causes and changing the code. It supports Claude Code, Codex, Cursor, and OpenCode, and is distributed directly from its GitHub repository rather than npm. The process keeps the API key locally and sends only explicitly supplied review context directly to the configured Jev API; it has no hosted backend, database, telemetry service, or author-operated proxy. The repository is licensed under MIT.
procedural-film is an agent skill that turns a topic into a 30-second vertical film. It uses vanilla JavaScript to draw every pixel on a canvas and Web Audio to synthesize every sound, producing a self-contained HTML player and MP4 exports without media assets. An agent plans the film, dispatches parallel subagents to write shot scene files, and runs critic reviews across the shots. The repository includes a shot-type index, scene and music guides, planning templates, a rendering engine, and a monarch-butterfly reference film. It requires Node.js 20 or newer, ffmpeg, and Chromium for Playwright; the project is licensed under MIT.
Mobile Jev is a standalone Android agent from droidrun that turns a written goal into device actions through the Mobilerun API, using TypeSafe's Jev to choose operations such as opening apps, tapping, entering text, scrolling, navigating, waiting, completing, or blocking. It observes the device, offers indexed controls and installed apps to Jev, validates the selected target against fresh screen data, executes the action, and observes the device again; it does not require an ADB connection. The executor resolves coordinates from observed bounds, rejects stale targets, records actions and execution traces, and verifies field values after text entry rather than relying solely on a model completion response. The project includes a local React studio with a live device stream, goal input, action timeline, task clock, model-latency measurements, stop and reconnect controls, and recent runs, along with a CLI for previewing or executing goals, inspecting devices, taking screenshots, profiling API timings, and issuing direct controls. It requires Node.js, pnpm, a Mobilerun Android device, and Mobilerun and TypeSafe API keys; it is intended for a single local operator, with recent runs held in memory. The repository is MIT licensed.
Abide is an open-source CLI and hook/plugin system that enforces project instructions for coding agents. It compiles AGENTS.md, CLAUDE.md, and other instruction files into a local rubric, then checks each edit and completed turn against the applicable rules. For each check, it sends the rule and changed code to Jev, TypeSafe's decision model, which returns a probability rather than free-form text; violations above the configured threshold produce a repair request for the agent. It supports Claude Code, Codex, and OpenCode, and also provides commands for auditing existing files, checking uncommitted changes, replaying sessions, reporting rule activity, calibrating rules against git history, and measuring latency and cost. The rubric is stored in .abide/rubric.json, while changed lines are sent to TypeSafe under the user's key with zero data retention requested. The project is licensed under MIT.
Claude for Financial Services is an Anthropic repository of reference agents, skills, slash commands, and data connectors for investment banking, equity research, private equity, fund administration, wealth management, and related financial-services workflows. Its named agents cover tasks such as pitch-deck preparation, market research, earnings review, financial modeling, valuation review, general-ledger reconciliation, month-end close, statement auditing, and KYC screening. The components can be installed as Claude Cowork or Claude Code plugins, or deployed as Claude Managed Agents through the Anthropic API. Agents bundle workflow-specific skills; vertical plugins provide reusable skills and commands such as comparable-company analysis, DCF and LBO modeling, Excel auditing, earnings analysis, diligence checklists, and investment-committee memo drafting. Centralized MCP connectors link the skills to external financial-data and document providers, subject to each provider's subscription or API-key requirements. The repository also includes managed-agent cookbooks, deployment and validation scripts, partner-authored plugins, and tooling for provisioning the Claude Microsoft 365 add-in. It is file-based, using Markdown, YAML, and JSON without a build step, and is distributed under the Apache License 2.0. The repository states that its agents draft work product for qualified-professional review and do not make investment recommendations, execute transactions, bind risk, post to a ledger, or approve onboarding.
firstmate is an agent distro that turns a terminal coding agent into a supervisor for a crew of autonomous coding agents. It provides instructions, skills, tooling, policies, and state conventions rather than a separately installed application: cloning the repository and launching a supported harness creates the primary “first mate” session. The first mate dispatches requests to visible agent sessions running in tmux, Herdr, Zellij, cmux, or Orca backends. Each crewmate receives an isolated Git worktree and performs either a ship task, which produces an authorized change for a pull request or local merge, or a scout task, which produces a standalone investigation report. An event-driven watcher supervises the sessions without continuously consuming model tokens, reconciles state after restarts, and reports results or escalates decisions to the user. Optional persistent second mates can run from isolated firstmate homes locally or on SSH-reachable hosts, and optional Relay support handles eligible mentions on X and Discord through the same task lifecycle. The repository supports primary harnesses including Claude Code, Grok, Pi, Oh My Pi, Codex, OpenCode, and Cursor Agent CLI, and requires Git and an authenticated GitHub CLI for the documented workflow. It is distributed under the MIT license.
BAML is a language and runtime for defining structured model interfaces and connecting agents to application code. It can repair malformed JSON outputs and was used with GPT OSS120B to find comments mentioning sponsors.
OpenShorts is an open-source AI video platform for turning long-form videos such as podcasts, webinars, livestreams, and interviews into 9:16 short-form clips. Its Clip Generator transcribes videos with faster-whisper, detects scene boundaries with PySceneDetect, uses an LLM to identify potential moments, cuts them with FFmpeg, and applies face-tracked or multi-speaker vertical layouts, word-level subtitles, hook overlays, effects, and optional dubbing. The platform also includes AI Shorts for generating UGC-style marketing videos with AI actors, scripts, voiceovers, b-roll, and lip-sync, plus YouTube Studio tools for thumbnails, titles, descriptions, and direct publishing. Clips can be distributed to TikTok, Instagram Reels, and YouTube Shorts through Upload-Post, and the system provides an MCP server, REST API, webhooks, CLI, and agent skill for automation. The core application can be self-hosted with Docker under the MIT license; a hosted version is available at openshorts.app, while the cloud service infrastructure is source-available under a separate commercial license.
Repowise is an open-source, self-hosted codebase-intelligence tool for developers and coding agents. It builds a local index of source code, dependency and symbol relationships, Git history, tests, documentation, architectural decisions, dead code, and code-health signals, then exposes the indexed evidence through an MCP server, local dashboard, CLI, editor integrations, and pull-request analysis. Its graph is built from AST-parsed code and Git data, with confidence-stamped call resolution, change-impact and co-change analysis, hotspot and ownership history, documentation-drift checks, decision evidence, and deterministic code-health detectors. The MCP interface provides task-oriented tools for repository overviews, cited answers, file and symbol context, code search, risk analysis, change risk, architectural rationale, dead-code detection, and health and refactoring plans. Optional model-written documentation and prose can be generated through a configured provider, while the core graph, risk, health, test, and dead-code analysis does not require LLM calls or an API key. Repowise also includes reversible command-output distillation for agents, proactive context hooks, generated agent instruction files, a GitHub PR bot, multi-repository workspace analysis, contract and cross-repository blast-radius mapping, and a VS Code extension. It can be installed with pip and run locally; the repository states that raw source is processed transiently and not persisted, while indexed graph data, embeddings, wiki pages, and Git metadata are stored. The core project is licensed under AGPL-3.0, with commercial licensing available for specified enterprise capabilities and embedding scenarios.
Hatchdoor is a self-hosted web application and MCP server for Obsidian-style Markdown vaults. It provides a browser interface and an MCP endpoint through which users and AI agents can browse, keyword-search, semantic-search, create, edit, move, and link notes, with wiki links, backlinks, graph views, metadata, Markdown rendering, attachments, and optional Git commits and pushes. Markdown files remain the source of truth; Hatchdoor builds a disposable SQLite read model for browsing, links, search, graph data, and metadata, rebuilding it from the vault if the cache is deleted. It is distributed as a rootless, distroless Docker or Podman container, with MCP and write access disabled by default. Hatchdoor is not a hosted synchronization service or multi-user collaboration platform. The project is licensed under the GNU Affero General Public License v3.0 only.
useAgent is an open-source AI coworker that gives Claude Code, Codex, OpenCode, and Pi a shared workspace with isolated Linux computers, repositories, terminals, browsers, and team tools. It can handle research, websites, spreadsheets, reports, presentations, and code changes, returning usable files, artifacts, or pull requests through a web app, Slack, REST API, or scheduled tasks. Each run is stored as an event log in Postgres and uses a common event contract across supported agent engines. Daytona or CubeSandbox provides the isolated workstation, while integrations cross a trusted gateway as typed tools so credentials remain on the control plane rather than entering the sandbox. The workspace also supports versioned skills and playbooks, team knowledge and memory, approval-gated tools, revisioned workpieces, and durable sessions. The repository describes useAgent as alpha software with changing APIs and schemas. It can be self-hosted on Linux using Bun and Postgres with pgvector, and is licensed under AGPL-3.0-only; a commercial license is available for proprietary embedding, distribution, OEM, or white-label use.
Deft is a self-hostable, open-source workspace where people and AI agents share chat, tasks, knowledge, calendar context, approvals, and action history. Its core workflow captures discussions as durable knowledge, lets the Defty agent use workspace context to propose task details, and routes proposed agent actions through configurable approval and trust policies before recording the approved work and its receipts. It also provides real-time conversations, task views, notes, knowledge graphs, calendar features, personal MCP connections, agent employees, native workspace tools, scoped access, revocation, and provider-neutral support for hosted or local AI providers. Deft can run without an AI provider as a conventional workspace. The self-hosting path uses Docker and PostgreSQL with pgvector; the repository is an alpha intended for technical evaluation, internal use, and controlled pilots. It is licensed under AGPL-3.0-only.
Stack Overflow for Agents is an API and platform for coding agents. It enables agents to search Stack Overflow posts, publish reusable discoveries, and report whether solutions from other agents worked.
Claude Code Templates is a CLI tool and web catalog for configuring and monitoring Anthropic's Claude Code. It provides installable agents, custom slash commands, settings, hooks, skills, MCP integrations, and project templates, which can be selected interactively or installed with commands such as `npx claude-code-templates@latest --agent ...`. The CLI also includes analytics for monitoring development sessions, a conversation monitor with optional Cloudflare Tunnel access, health checks for Claude Code installations, and a plugin dashboard for viewing marketplaces, installed plugins, and permissions. The project aggregates components from Anthropic and community sources, while retaining their stated licenses and attributions; the project itself is licensed under the MIT License.
Treg is a registry and proxy for agent tools, developed by Superdesign. It gives an agent one base URL and token for discovering and calling catalogued endpoints from multiple providers, while also allowing teams to register their own APIs, OAuth connections, vendor CLIs, and SKILL.md bundles. Catalogued calls can use Treg's provider credentials, a team's credentials, or a verified public route; calls are priced per use when Treg's credentials are used. Its proxy resolves a tool by name or upstream URL, decrypts stored secrets, injects credentials using environment, secret-file, OAuth, or CLI-auth bindings, relays the request, and records an audit event. The proxy is designed to leave upstream requests and responses intact apart from transport and Treg control headers and the injected credentials. The `treg` CLI supports catalog search, tool calls, credential health checks, tool and skill registration, CLI execution, OAuth connections, organizations, and team access controls. It also exposes MCP surfaces for compatible agents and provides a hosted service at treg.to; the server can be self-hosted with the server installation extra. The repository is licensed under Apache 2.0 with additional terms restricting redistribution as a competing hosted registry service.
Strands Agents is an open-source AI agent SDK and harness for Python and TypeScript, developed by AWS. It runs the agent loop in the user’s process without a hosted control plane and uses a model-driven architecture based on system prompts, tools, and a selected model. It provides lifecycle controls, structured output, MCP support, multi-agent patterns, memory and sessions, model-provider portability, streaming, guardrails, tracing, evaluations, hooks, telemetry, context management, and deployment support. It supports providers including Amazon Bedrock, Anthropic, OpenAI, Gemini, and others. The repository includes assembled Python and TypeScript harnesses, lower-level SDKs for building custom agent loops, a command-line tool for prototyping and chatting with harness agents, supporting packages, and the documentation site. The harness packages provide batteries-included agents through create_harness() in Python or createHarness() in TypeScript, while the SDKs expose the loop, tools, model providers, memory, sessions, and hooks for deeper control.
An API that provides structured, specialized tennis-serve data and serve-quality scores for AI agents to retrieve and use when analyzing tennis serves. It is presented as a source of real-time, LLM-ready tennis context that can be connected to an agent's tool-calling workflow.
magpie is a cross-platform menu-bar and command-line application for selecting models used by local coding agents. It detects configured agents, lets users change their provider, model, and related settings, edits only the changed keys in configuration files while preserving formatting, and saves profiles for switching groups of agent configurations. It also runs a local gateway at 127.0.0.1:3425 that exposes OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, and Google Gemini-compatible endpoints. The gateway translates requests between these APIs, forwards them to configured vendors or local servers, and presents provider models through a shared provider/model catalog; signed-in Claude Code, Codex, and Copilot accounts can also be used as providers. A terminal UI, plain CLI, provider management, model-list refreshing, import links, and encrypted backup and restore are included. The application is distributed for macOS, Linux, and Windows, with a smaller terminal-only build, and is licensed under the MIT License. Its official homepage is usemagpie.ai and its source repository is maintained at yetone/magpie.
Foremerge is an open-source coordination protocol and CLI for parallel coding agents, developed by naw103 and built above Git. It gives agents isolated Git worktrees while recording shared intents, semantic scopes, claims, dependencies, ChangeSets, decisions, validation results, and provenance in a local SQLite store under the repository's Git common directory. Agents publish what they intend to change before editing. Foremerge compares typed scopes such as symbols, APIs, schemas, configuration, infrastructure, tests, migrations, files, components, contracts, and domains, producing deterministic, explainable conflict advisories and related-work information. Claims are leased and advisory rather than exclusive: the system does not lock files, block agents, or ask a model to judge conflicts. Its workflow can publish and validate a ChangeSet against a recorded Git fingerprint, require a clean worktree and resolved high-severity conflicts for acceptance, and record the eventual integration commit without merging, rebasing, cherry-picking, or pushing code. The project provides a Rust CLI, JSON API, MCP server, SQLite coordination store, Git worktree support, and integrations for Claude Code, Codex, and Cursor. It is a local-first pre-1.0 MVP; coordination across machines is outside its scope, validation commands run with the local operating system's permissions, and the project reports no published benchmark results. Foremerge is distributed under the Apache License 2.0.
Fast Browser Use is a local-first browser automation engine and agent skill for Claude Code, Codex, Cursor, and Python workflows. It runs Qwen3.5 models locally through MLX or PyTorch on Apple Silicon, CUDA GPUs, or CPUs, without cloud inference. The engine scans the rendered page for visible, interactable controls and converts them into bounded action candidates such as click, select, type, and done. It maps those candidates to single vocabulary tokens, scores them with one forward pass, and dispatches the selected browser action instead of generating CSS selectors, XPath expressions, or Playwright code. Text generation is used specifically for typing into fields, while structural actions use discrete logits scoring. The runtime also includes page-settling waits, visibility and occlusion checks, DOM-freshness checks, read-only protection, immutable execution traces, and external URL, title, and text assertions for outcome verification. The project provides a command-line interface, a Python API, and installable agent-skill integration, using Playwright Chromium for browser execution. It supports offline model operation after local weights are downloaded and is released under the MIT License.
JevRouter is a local-first agent capability router for models, subagents, skills, MCP tools, CLIs, and DSH plugins. It presents these capabilities as one candidate set and uses Jev for typed selection while enforcing availability, permissions, risk, and confirmation policies. It is decision-only by default and does not execute selected tools implicitly. The `route` operation answers one capability-selection question; `plan` selects capabilities for multiple steps using serial, batch, or decomposed strategies, with optional beam sequence search and contextual routing. Candidates can be supplied inline or discovered from Skill directories, MCP configurations, CLI help output, and DSH manifests. The router preserves Jev probabilities and provider responses, validates supplied permissions and input schemas, filters unavailable or disallowed candidates, and can select a safe fallback while retaining the original Jev choice. The CLI, Node.js SDK, HTTP server, and MCP adapter expose the routing contract. Decisions and plans are written as append-only receipts with provenance hashes, and a local dashboard reads those files without making provider requests or uploading data. It supports the official Jev API and OpenRouter, has an offline demo provider, requires Node.js 20 or later, and is distributed under the MIT license.
Jevmind is a Python decision layer for software agents. It turns agent decisions into typed answers such as yes/no results, choices, and scores with confidence values, then applies a code-defined gate: uncertain answers escalate, trusted positive answers may act, and trusted negative answers are held. Its decisions are recorded in an append-only, hash-chained ledger, graded against later outcomes, and optionally recalibrated with Platt scaling. It includes nine skills for compacting tool output, navigating repositories, reviewing diffs, routing tasks to model tiers, checking completion claims, curating training data, walking linked markdown vaults, guarding commands, and running a structured-state control-loop demo. The default local brain uses readable rules, reflexes, and BM25 retrieval without a language model; an optional Jev HTTP brain can answer the same typed questions, while replay mode uses recorded answers. Jevmind runs as a command-line tool and MCP server, includes a Claude Code hook for shell-command screening, supports Python 3.10+, has no runtime dependencies, and is distributed under the MIT license.
A personal Codex skill and orchestration workflow for splitting software-development tasks between GPT-6 Astra and DeepSeek V4.1 Flash. Astra handles planning, architecture, high-stakes decisions, task briefs, and final review; Flash handles scoped repository discovery, implementation, testing, debugging, and routine verification, then returns a patch and evidence for Astra's acceptance pass. The workflow supports existing plans and phased implementation bundles, normally uses one writer, and includes verification, checkpointing, dry-run installation, backups, and guarded undo receipts. It is an early release requiring a Codex client with native subagents, Python 3.11 or newer, GPT-6 Astra as the root model, and an already configured Codex Router route for DeepSeek V4.1 Flash. It installs a skill, a named builder agent, and a scoped workflow policy without changing credentials, the root model, or Router configuration; no third-party Python dependencies are required.
Mr. Mak Workspace is a local Windows desktop workspace for Codex CLI and Claude Code CLI. It combines real CLI chats with a project workspace for folders, research, images, files, Markdown documents, project reports, and saved project materials. The application provides chat history and tabs, agent activity indicators, file and folder insertion, project cards, previews for media files, and a right rail for project skills, knowledge, workflows, MCP connections, settings, and help. The repository includes fourteen project skills covering areas such as planning, handoffs, image references, media generation, Three.js, Blender, video inspection, and dictation. It can also provide an optional voice coordinator using Codex CLI and an OpenAI API key; external providers and MCP connections are optional and use the user's own accounts. The Windows installer includes the local Node service but does not bundle the supported CLIs or provider accounts. The native application targets Windows x64, while browser report previews can run elsewhere. Application code and original workflow documentation are MIT-licensed, with third-party skill materials retaining their original licenses.
ThinkingOrbs is a SwiftUI package by Haplo LLC that provides dotted 3D loading indicators for AI and agent interfaces. It includes nine hand-tuned designs representing states such as searching, solving, listening, connecting, composing, and waiting; eight use rotated, depth-shaded, z-sorted 3D forms and one uses a morphing outline. The package provides regular and small sizes, status-label views with optional shimmering text, localization and accessibility labels, speed and pause controls, and public frame geometry for custom renderers. Each orb is drawn with grayscale dots in a Canvas inside a TimelineView. Timelines pause when an orb is offscreen or the app is backgrounded, while Reduce Motion displays a representative static frame. The package supports iOS 17+, macOS 14+, tvOS 17+, watchOS 10+, and visionOS 1+, and is distributed as a Swift Package under the MIT license.
Herdr GPUI is a native Rust/GPUI desktop client for a separately installed Herdr daemon. It displays the daemon's terminal sessions, split panes, workspaces, Git worktrees, and agent activity without running another terminal emulator or wrapping the TUI. The daemon owns terminal processes and session state. Herdr GPUI connects to its local or saved remote daemon through the Herdr client socket, receives binary protocol frames and surface patches, renders the terminal surfaces, and sends semantic input back; closing the GUI leaves the daemon and its sessions running. The project is distributed from the repository as a signed, notarized macOS app through Homebrew, with additional Linux packages, experimental Windows builds, Nix support, and source-build instructions. The daemon must be installed separately. It is licensed under Apache-2.0.
Paperclip is an open-source, self-hosted control plane for organizing and running teams of AI agents. Its Node.js server and React UI let users define company goals, assign agents roles and tasks, and monitor work, budgets, approvals, costs, and audit activity from a shared dashboard. Agents run through scheduled or event-based heartbeats. The system maintains organization charts, goal ancestry, task dependencies, persistent session state, isolated workspaces, scoped secrets, runtime skill injection, and atomic task checkout with budget enforcement. It supports agent adapters and runtimes including Claude Code, Codex, Cursor, Bash, HTTP/webhook agents, and plugins; recurring routines can create tracked issues and wake assigned agents. Paperclip supports multiple isolated companies in one deployment, governance and approval gates, cost hard stops, agent pause/resume/termination, company export and import with secret scrubbing, and optional OpenTelemetry and Sentry integrations. It can be installed through the Paperclip CLI or run from source; local setups use embedded PostgreSQL and file storage, while production deployments can use an external PostgreSQL database. The project is distributed under the MIT license.
OpenRig is an open-source, self-hosted multi-agent harness for coordinating AI coding agents such as Claude Code and Codex as one managed team. It uses a local daemon, CLI, terminal UI, MCP server, SQLite, tmux, and runtime adapters. Users define agent topologies in YAML with pods, seats, communication edges, and continuity policies, then use commands such as `rig up`, `rig send`, `rig broadcast`, `rig chatroom`, `rig down --snapshot`, and `rig discover`/`rig adopt` to launch, coordinate, inspect, snapshot, restore, or take over existing sessions. Its MCP tools let agents manage their own topology, while the TUI exposes topology, seat, project, feed, terminal, and system views. OpenRig requires Node.js and tmux; herdr, cmux, and Docker are optional for terminal workspaces and service-backed rigs. It is distributed through the `@openrig/cli` npm package and licensed under Apache 2.0.
Whiteboard is an open-source desktop app for humans and coding agents to architect software in a shared workspace. It connects to agents such as Claude Code and Codex, giving them an SDK for drawing diagrams and describing their work on an in-app canvas. Visualizations including sequence diagrams, entity-relationship diagrams, and agent-trace quotations can link directly to underlying code, while the code-review interface provides VS Code keybindings and LSP support. Whiteboard includes a semantic, AST-aware diff viewer written in Rust. It summarizes large added functions as pseudocode and can collapse or hide changes such as tests and documentation; a WebAssembly-based plugin system makes these rules customizable. Its decision-log tools let agents query and link their traces so users can inspect requirements, implementation choices, and autonomous decisions. The app runs against local checkouts, is distributed for macOS, Windows, Ubuntu, and Fedora, and is licensed under the MIT License. It is self-hostable, although hosted team functionality is planned. Current limitations include no file editing within Whiteboard and limited support for reviewing multiple repositories together.
NeoHorse is TokenRhythm's family of open-weight causal language models for text-based agent workflows, including tool use, coding, and instruction following. NeoHorse-1 uses routing-guided agentic post-training: a harness assigns tasks to a heterogeneous model pool, records tool interactions and outcomes, estimates capability demand, and feeds capability-level feedback into later training mixtures. Updated models can return to the harness in an evaluation-selection-update loop intended as a prototype for recursive self-improvement. NeoHorse-1 is released in approximately 4B and 9B parameter variants, post-trained from Qwen3.5 models, with text input and text output interfaces and deployment examples for vLLM and SGLang. The related NeoHorse-Jev-4B model uses prefill-only inference to return structured Choice, Noul, and Score decisions and probabilities for routing requests, selecting tools, or controlling workflows. The models are released under the Apache License 2.0.
Jive is an open-source terminal coding agent that plans work as executable graphs. It replaces sequential tool calls with graph calls: the planner produces a directed acyclic graph containing tool calls and Jev calls, allowing the agent to perform multi-step profiling, dataset analysis, and repetitive tasks with fast decisions inserted between harder reasoning steps. The project emphasizes a lightweight, token-efficient agent scaffold with eager execution, flexible graphs, and support for system-one and system-two models. It can be installed with the project's shell installer and is distributed under the MIT license.
cli-faq-shortcuts is an agent skill that analyzes a developer's coding-agent history and turns repeated requests into project-specific slash-command shortcuts for Claude Code, Codex, and Cursor. Its local extractor reads prompts from the relevant Claude Code, Codex, and Cursor history files, excluding subagent turns and scripted runs. The agent groups differently worded prompts by intent, counts recurring asks, checks existing shortcuts and project tools, and presents candidates for the user to select. Each selected shortcut is written as a SKILL.md file under the project’s .claude/skills directory, linked through .agents/skills so the supported agents can load it; the repository also records mappings in CLAUDE.md or AGENTS.md. Shortcuts can point to existing scripts and queries, include project-specific cautions, and use a dry run before actions that write or send data. The extractor can be run independently with Python and reads local files without making network calls. The repository supports installation on macOS, Linux, and Windows, and is licensed under Apache-2.0.
Keel is a local-first native macOS coding workspace that runs coding agents through a Rust/GPUI application. It combines sessions, a composer, transcripts, a terminal, change inspection, settings, Git history, crash recovery, and an agent graph showing active agents, subagents, and files as shared context; agents can be steered or stopped from the graph. It connects Claude Code, Codex, Cursor, Grok, Hermes, and pi through the Agent Client Protocol, and also includes an embedded DeepSeek agent loop with host-enforced tool focus. For unpinned tasks, a local Laya selector running through Core ML or an optional hosted Jev selector chooses among host-prepared routes or abstains. Keel validates each choice before applying it, falls back to the ordinary route when a choice is rejected, stale, or expired, and records candidates, validation, fallback, and observed outcome in bounded decision receipts. Decision receipts can be exported as JSONL and summarized with CLI reports. Keel also provides headless and daemon modes, while each coding provider retains its own authentication, model configuration, and tool loop. The repository supports Apple Silicon and macOS 15 or later for the packaged Laya model. It can be built from source, but the repository does not currently publish downloadable app releases; packaged builds are ad hoc signed development builds. Automatic training, public installer distribution, cloud sync, and native Codex realtime voice are not implemented or included in this build.
An agent skill for Claude that guides logo projects from discovery briefs through concept development, SVG construction, testing, refinement, and delivery of brand assets. Its workflow researches category conventions in a classified library of more than 1,400 reference SVG logos, develops 8–12 concepts, builds selected concepts in SVG, and pauses at a checkpoint for direction selection before producing a full kit. Dependency-free Python tools audit SVG structure and craft rules, generate concept and test sheets, check marks at sizes down to 16 px in one-colour and reversed treatments, compare them in contextual and competitor-shelf tests, render PNGs, create presentation boards, and export favicon, app-icon, web-manifest, lockup, and other variants. It can also produce icon sets and brand-guideline materials. The skill follows the Agent Skills format, supports Claude Code, Claude.ai, Claude Desktop, and compatible agents, requires Python 3.8+ for its tools, and is distributed under the MIT license; the reference logo files are third-party trademarks excluded from that license.
LaunchVideo is a tool that turns a website URL or prompt into a 20–40-second launch video. Opus 5.5 writes a single HTML film, while a serverless OpenComputer agent checks the scene at multiple timestamps and renders each frame in headless Chromium under a controlled virtual clock. The frames are encoded into an MP4 with ffmpeg and uploaded to Vercel Blob. The project includes a Next.js web form, OpenComputer agent configuration, API routes for job creation and status, and a CLI or one-click deployment path. URL inputs are fetched for page metadata, headings, colors, and Google Fonts before generation. Rendering runs in a fresh Amazon Linux arm64 microVM and supports deterministic HTML scenes subject to restrictions such as no video, audio, iframe, CSS transitions, random values, or external images.
YuE2 Studio is a Windows desktop application for local AI song generation. It takes a musical style and lyrics, uses YuE2 to compose a melody and chords as ABC notation, engraves the result as sheet music, and renders the composition as a full song with vocals. The score can be edited and rendered again with different sounds, while saved audio codes support exact replay and variation without recomposing. The studio also supports score-first composition, melody transcription for covers through SheetSage2, lyric-level karaoke timing, six-stem separation, audio-to-MIDI conversion, LoRA loading and training, audio processing with VST3 plugins, and an optional local or OpenRouter writing assistant. It can be controlled by AI agents through a local MCP server. It is distributed as a native Windows installer with auto-update or a portable folder and does not require Python or Node.js at runtime. Generation runs offline through the bundled yue2.cpp engine on NVIDIA, AMD, or Intel GPUs, with Vulkan support for the latter two described as experimental; CPU execution is also available. The studio is MIT-licensed, while the YuE2-3B, YuE2 VAE, and SheetSage2 models are CC BY-NC 4.0 and restrict generated songs to non-commercial use unless other terms are obtained.
Omarchy Meeting Recorder is a local meeting-recording application for Omarchy on Hyprland, built with Rust, GTK 4 and libadwaita. It captures microphone audio and the computer's output as separate tracks, then uses whisper-rs and a local Whisper model to produce a timestamped transcript with speaker labels. Recordings can also be imported from files; imported single-track audio uses NVIDIA Nemotron 3 Diarization through ONNX Runtime to distinguish speakers locally. The application provides an editable transcript, waveform playback synchronized with transcript lines, speaker renaming, chapter markers, pause and crash recovery, command-line controls, and optional bar-widget integration. Chapters can be generated by the configured Omarchy coding agent; in that case, the transcript text is sent to that agent, while recording and transcription otherwise remain on the user's computer. It stores meetings as folders containing audio, Markdown transcripts, metadata, and separate track files. The project is distributed under the MIT license and can be installed from the Omarchy package repository or built from source.
mu (μ) is a coding agent with a judgment kernel, built on pi and AionUi. A small judge handles bounded decisions around context admission, command risk and approval, task framing, memory, completion, drift, browser actions, and multi-agent coordination, while the main model performs the coding work. Each decision can be active, shadow, or off and can use Jev, the local Laya judge, or another LLM; verdicts, probabilities, and timings are recorded in a local ledger that can be inspected from the command line or desktop app. The system admits tool output chunk by chunk, archives or removes stale context, applies rule-based safety checks before judgment, and uses a shared board to route findings among non-editing sub-agents. It provides an npm-installed command-line interface and a native desktop app, supports model-provider connections and importing Claude Code or Codex conversations, and states that it is in early development with no release yet; names, settings, and formats may change.
Jevry is an open-source, MIT-licensed desktop browser agent created by Michael Swissa. It is an Electron browser that combines a language model for planning and text or visual reasoning with TypeSafe's Jev model for selecting typed actions from controls observed on the current page. Chromium executes the selected operations through guarded native input rather than generated JavaScript, arbitrary selectors, or shell commands. Its loop observes page text and compatible controls, compiles supported operation-and-target choices such as clicking, typing, scrolling, or stopping, asks Jev to choose, validates the choice against the current document and target, executes it, records an input receipt, and checks the resulting evidence before continuing. It supports browser tasks such as forms, page-grounded questions, research and citation, documentation navigation, catalogs, and selected visual or numeric games. The project is an experimental developer preview for macOS and Windows; it requires a TypeSafe Jev connection plus a text-model connection, and some capabilities—including uploads, extensions, password-manager workflows, and certain cross-origin interactions—remain unsupported or unverified.
Jevgrep is a command-line tool for coding agents that finds relevant files and source context in unfamiliar repositories from natural-language questions. It uses Jev to judge relevance across folders, files, and declarations, explores qualifying branches of the repository hierarchy, selects files through content previews, identifies useful source units and surrounding context, and returns a summary followed by file locations, reading leads, and verbatim excerpts with line references. Python and TypeScript/JavaScript support declaration parsing, while other text uses a fallback. It also includes an agent skill that teaches supported coding agents when to invoke the CLI and how to use its results. The CLI is distributed through npm as @dzhng/jevgrep, requires Node.js 22 or later on macOS or Linux, and requires authentication with a supported AI provider. Searches send eligible source content to Jev through the selected provider; local filtering excludes ignored, hidden, dependency/build, binary, and obvious credential files but is not a guarantee that sensitive data is removed. The project is MIT-licensed.
A private, subscription-based online community hosted on Skool by Jay E for learning how to build and sell AI systems. Its curriculum includes an Agentic AI Masterclass covering Claude Code, Hermes, and the broader AI-agent stack, plus an Agents as a Service course on finding clients and scaling an AI agency. Membership also includes AI lessons and guides, automation templates, access to the Rubric agentic operating system, and a network of AI practitioners.
RUBRIC is a visual command centre for AI agents, centralizing flows, skills, agents, scheduled jobs, generated media, documents, links, and sprint tasks in one dashboard. Its panels include a flow visualizer with pipeline playback, a skill-tree graph that maps capabilities, an agent activity view, a cron calendar, a generations log for image and video outputs, and a markdown knowledge base. RUBRIC is installed by copying a prompt from the RoboNuggets classroom into an AI agent. The agent pulls the repository, installs the scaffold, and configures the tabs; the page says it works with Claude Code, OpenClaw, Antigravity, and other agents that operate in files. The page presents it as free for RoboNuggets community members.
The Launchpad Build Cohort is an eight-week, application-based AI engineering program led by Marina Wyss. Participants choose, scope, build, and deploy an AI system rather than receiving a fixed project specification; it is intended for people who can already write basic Python programs, use Git and GitHub, and understand concepts such as RAG, agents, and MCP. The program uses weekly deliverables, a small-group format, live calls, Slack support, and weekly code review. Weeks 1–2 cover project selection and a scoping document; weeks 3–6 focus on building and iterative review; and weeks 7–8 cover deployment, polishing, and a demo. Participants finish with a deployed system, a rehearsed demonstration, a README, and an interview-preparation document based on their project decisions. The cohort is designed for roughly 10 hours of work per week and includes the use of AI coding tools without outsourcing the participant’s technical decisions. The page states that the October 2026 cohort is full and offers a waitlist for the next cohort.
Databox is an agentic analytics platform for agencies and teams. It connects data from tools, spreadsheets, databases, and APIs, defines governed metrics through a semantic layer, and combines dashboards, reports, goals, and KPIs with AI analysis. Its AI Analyst answers questions using live data, while agents and automations run recurring analysis and follow-up workflows; its MCP capability grounds AI tools in Databox data and business context. The platform states that data is encrypted and access-controlled and is not used to train AI models.
BAND is an enterprise-grade platform for real-time collaboration between AI agents and humans across frameworks, languages, runtimes, and deployment environments. It provides a shared interaction layer with agent communication, discovery, delegation, conversations, rooms, participants, routing, ordered transport, persistence and rehydration, runtime binding, identity, observability, and governance, allowing agents built with systems including Codex, LangGraph, Claude Code, and personal assistants to discover one another and collaborate without point-to-point integrations. BAND supports shared rooms in which humans and agents collaborate while each agent retains its own tools, models, and memory. Its offerings include the BAND Platform for building multi-agent systems and BAND Desktop for controlling and observing coding agents and enabling their collaboration.
Graphite is an AI code review platform for teams using GitHub. It supports creating, reviewing, and shipping changes within pull requests, and its evaluation set is built from developers accepting or rejecting its review suggestions. The service is presented as a way to review and deliver software in workflows that include autonomous coding agents.
Arize AI is an AI agent observability, evaluation, and improvement platform. It provides tracing, evaluation, and experimentation, using production signals to support continual improvement of agents. The platform is available through Arize AX and a terminal-based setup.
OpenAPPA is an open-source security tool for agentic applications. It sits between an agent and its tools, tracking the sensitivity and trust of data the agent reads and checking every outbound action against a policy before dispatch. Its APPA (Agentic Permissions Policy Algebra) engine uses declarative TOML policies and a pure decision core based on the event log, so it can run in-process from Rust or Python or as a sidecar. The project includes integrations for Claude Code and Amp, with checks applied to tool calls and results. OpenAPPA is currently a preview and RFC, and its configuration and wire interfaces may change.
Codex ChatGPT Web is an unofficial launcher that uses browser automation to make ChatGPT Web models, including available Pro models, selectable as native models inside the Codex coding agent. It preserves ChatGPT Web features such as context, images, streaming, and separate usage limits, and its Full harness mode connects ChatGPT tool calls to the current Codex task's files, terminal, tools, and approvals through MCP. A Zero Risk mode lets users paste prepared prompts and send them manually while using a separate MCP connector. The launcher bundles its browser and runtime, supports macOS, Windows, and Linux releases, and is distributed under the MIT license. It is not an OpenAI API or OpenAI-affiliated product; its browser automation depends on the ChatGPT interface and can be affected by UI changes.
Open Slide is a presentation framework built for AI coding agents. An agent describes a deck in natural language and writes React pages, while Open Slide provides a fixed 1920 × 1080 canvas, scaling, navigation, hot reload, presentation and presenter modes, and an in-browser inspector. Its agent skills support deck creation and slide authoring; the inspector records element comments as source markers that an agent can apply. The framework also manages images, video, fonts, and SVG logos, and exports decks as static HTML, PDF, or editable PPTX files. It is distributed as a pnpm/Turbo monorepo with an `@open-slide/cli` scaffolder and `@open-slide/core` runtime, and produces static builds deployable to standard static hosts. The repository is MIT-licensed.
px0 is a browser-based IDE for reviewing AI-generated code, developed by px0-ai. It provides native Git and GitHub integration for pull-request and unpushed-commit review, including scoped diffs, inline draft comments, staging, commits, and pushes. Its navigation tools include fuzzy file search, symbol outlines, workspace-wide regular-expression search, and virtual rendering for large files, while its browser interface can hand edits to local coding harnesses such as Claude Code, Gemini CLI, Cursor Agent, OpenCode, Codex, Aider, and Goose. px0 is distributed as a static Go binary with no runtime dependencies and can run locally or on a remote server, VM, or container; the project is MIT-licensed.
Coucou is an open-source desktop companion for Claude Code and other coding-agent sessions, appearing in the macOS notch or as a top-of-screen island on Windows. It displays session events such as files read, edits, and commands run; surfaces Claude Code permission requests for Allow/Deny approval; opens the relevant terminal on macOS; provides built-in Claude chat; and accepts dropped files as context. It can also attach a macOS window as Claude context and display optional integration pills for services including GitHub, Vercel, Notion, and others. On macOS, a hook script forwards Claude Code events over a Unix socket and waits for approval responses, while a borderless NSPanel and a SwiftUI Canvas render the animated Mochi character. The native Swift 6, SwiftUI, and AppKit application has no third-party dependencies. On Windows, a Tauri 2 application uses Rust, TypeScript, a transparent always-on-top window, Canvas 2D rendering, and a named pipe for hook events. The project states that it collects no telemetry, requires no account, and stores credentials in the macOS Keychain or Windows Credential Manager. Coucou is distributed from the project's releases and can also be built from source. The code is licensed under MIT; the Mochi name, character, icon, sounds, and media are separately reserved by the author. The Windows installer is temporarily unavailable according to the README because its unsigned build was flagged by Microsoft Defender.
DSCODE is a macOS terminal coding agent and CLI built on DeepSeek Harness. Its persistent shell retains the working directory, environment, background jobs, edits, searches, patches, and test runs, while the TUI, CLI, and scripts share one session runtime. Sessions can hand tasks to other sessions, run side questions in read-only child sessions, delegate work to child agents in isolated Git worktrees, and use an independent read-only model to review changes and approve permissions. The `dscode exec` command supports non-interactive scripts and CI, with output streamed to stdout and tool activity and session identifiers sent to stderr. It also supports MCP servers, triggers, cross-session memory, multiple model providers, and a workspace-write sandbox with human-approval and automatic-review modes. Distribution is available through npm, Homebrew, GitHub release tarballs, and source; the project requires macOS 14 or later and is licensed under MIT. It is an independent community project, not an official DeepSeek product.
onetake is a Claude Agent Skill for creating product launch films, teasers, and feature demos as continuous one-take animations rather than sequences of cuts. It rebuilds product interfaces from screenshots in HTML, places them on the camera plane, and uses a motion library of measured spring, entrance, carry, collision, simulation, camera, and fluid-light movements. Its workflow requires a beat sheet in which each boundary identifies what survives into the next beat, then renders deterministic frames with sampled linear-light motion blur and event-based sound. Before a film is shown to a human, probe.py records frame contents, detects beat boundaries, and uses a continuity oracle to check whether visual elements carry across them. The verification also rejects uniform shot timing, missing stillness, clipped audio, fast movement without blur, and subjects leaving the frame. The repository includes rendering, verification, probing, reference-analysis, still-image, footage, narration, and sound scripts, with draft output at 1080p30 and final output at 4K60. It requires Python with Playwright and Chromium, NumPy, SciPy, Pillow, and Matplotlib, plus FFmpeg and Node; narration additionally uses faster-whisper and Kokoro TTS. It is distributed under the PolyForm Noncommercial 1.0.0 license, which permits personal, educational, research, and other noncommercial use but not commercial use.
ReelMimic is a local 2D animation tool that uses Claude Code or Codex to create a new video from a reference video and a brief. It analyzes the reference's shot count, pacing, BPM, transitions, framing, colors, and camera movements, then produces a storyboard, character and asset plan, and style frames for approval. After approval, multiple AI agents build different parts in parallel, while separate agents review completed shots and request fixes with before-and-after screenshots. The tool supports seven drawing engines: vector/motion graphics, hand-painted watercolor, crayon picture book, pixel art, paper cut-out stop-motion, whiteboard doodle, and anime cel; new styles are defined in Markdown. It runs on the user's computer, uses the user's Claude Code or Codex account, and does not reuse the reference video's footage, characters, logos, or assets. The repository is MIT-licensed and has been tested primarily on Windows, with macOS and Linux support described as less tested.