1,038 tools and products — trending open source, and what gets used in AI and other work.
OpenJV is an implementation that reproduces Jev's interface by reading option probabilities from a frozen model in a single forward pass.
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.
WhaleRead is a local-first macOS workspace for translating and reading TXT, Markdown, and EPUB books. It displays the source and translation side by side, preserves reading position, bookmarks, notes, review history, EPUB chapters, images, and styling, and supports switching between source, translation, and bilingual views. Book translation runs on-device with Hy-MT2 7B; the page also describes a user-controlled self-hosted 30B route, which is not included in the public download. Its review workflow keeps model suggestions separate from the book: users can highlight a passage, inspect the source evidence and model reasoning, edit or discard a suggestion, and apply a revision only after confirmation. Ask AI can answer questions about selected passages through a compatible endpoint configured by the user, with the prepared context shown before sending and answers saved as reading notes without automatically changing the book. The public preview is for Apple silicon Macs running macOS 13 or later. The page says the preview is ad-hoc signed and not yet notarised by Apple, and that the 7B model is downloaded separately.
Simple Commenter is a website-feedback platform with an MCP server that connects client comments, captured page and element context, developer briefs, and design assets to AI tools. Its hosted MCP endpoint supports OAuth connections to ChatGPT, Claude, and Codex, with access restricted to selected companies, projects, and actions. Cursor and Claude Code can use a local npm-based server configured through `@simple-commenter/mcp-server`; the setup provides commands for initialization, serving, and diagnostics. AI coding tools can investigate open feedback, propose code changes, post replies, and update comment status, while users review and test the resulting changes.
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.
NVIDIA Model Optimizer (ModelOpt) is an open-source library for optimizing deep-learning and generative-AI models for inference deployment. It accepts Hugging Face, PyTorch, or ONNX models and provides Python APIs for composing post-training quantization, quantization-aware training and distillation, pruning, neural architecture search, speculative decoding, and sparsity techniques, producing optimized or quantized checkpoints. The resulting checkpoints can be exported for inference frameworks including TensorRT-LLM, TensorRT, vLLM, and SGLang. The library also integrates with NVIDIA Megatron-Bridge, Megatron-LM, Hugging Face Accelerate, Transformers, and Diffusers for supported training and export workflows. It is distributed as the nvidia-modelopt package on PyPI and can also be installed from the NVIDIA GitHub repository or used through NVIDIA container images.
Bend 2 is a parallel programming language created by Victor Taelin and contributors, designed for AI-written code that must preserve declared rules. Its Python-like syntax includes dependent types, purity, linearity, and explicit proofs. A project can define invariants in a `LAWS.bend` file and provide proofs in `PROOF.bend`; the compiler checks those proofs when code changes, blocking implementations that violate the declared laws. Bend uses divide-and-conquer parallelism rather than manually managed threads, locks, or GPU kernels, and can target CPUs and GPUs through C, CUDA, and Metal, with JavaScript also supported. It is distributed through an install script and is positioned primarily for Linux and macOS; the repository describes it as a young language with limitations including no Windows support, no proof search, slow native compilation, and experimental areas of the compiler and runtime.
Laya-CoreML is an open-weight on-device decision-model runtime and port of Laya for Apple Silicon, using Core ML and Apple's Neural Engine. It answers typed choice, ordinal-score, and boolean questions with probabilities or scores rather than generating text or JSON; its Python API loads a model and returns structured answers. The repository includes Core ML checkpoints, tokenizer and configuration files, an offline Python package, a command-line Snake demo, and conversion and benchmarking tools. The Neural Engine bundle uses a short fixed-capacity input path, while longer or general-purpose requests can use CPU-and-GPU checkpoints. The project documents a separate Neural Engine graph using BC1L activations, 1×1 projections, and per-head attention, with CPU handling input and output boundaries. It supports macOS 15 or later on Apple Silicon and can run without PyTorch, Transformers, or MLX at inference time. The project is licensed under Apache-2.0 and describes itself as an independent port by Convai Innovations and contributors, not an official Convai Innovations or Apple release.
Bespoke Nimble is an open-source model, training recipe, and local scoring library from Bespoke Labs for making typed decisions about text. Given a context and a flat schema of boolean or fixed-choice fields, it selects an allowed answer and returns candidate logits and probabilities without generating a reasoning explanation or free-form answer. Nimble fine-tunes Qwen3.5-9B with LoRA using contrastive training pairs: two nearly identical examples differ in one relevant fact, which changes the correct label. At inference, the scorer reads the logits for one-token candidate codes and converts them to probabilities with softmax; the Python library constructs the typed result rather than parsing generated JSON. The MLX ParallelScorer processes shared context once and scores fields in parallel, while the CUDA scorer scores each field separately. The repository includes the model recipe, curation and evaluation code, datasets, examples, tests, and deployment documentation. Bespoke-Nimble-9B can run locally on Apple Silicon or an NVIDIA BF16-capable GPU. It accepts text only, does not support nested schemas or answers outside the supplied choices, and its probabilities are not guarantees of correctness.
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.
Shapeshift is a browser-based natural-language interface that turns one text input into structured cards such as events, checklists, timers, color pickers, bill splitters, converters, polls, contacts, and notes. Its intent layer can use TypeSafe AI's Jev model to answer typed questions in parallel, while deterministic parsers handle dates, amounts, units, and calculations; a built-in keyword classifier provides offline operation without an account. A state machine stabilizes changing classifications as text is entered, and saved cards remain in the browser's local storage until deleted. The open-source project is built with Next.js, React, TypeScript, and Tailwind CSS and is licensed under MIT.
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.
FluidUse is an open-source macOS library and demo application for local computer use on Apple silicon. It reads forms in running Mac applications or browsers through the macOS Accessibility API, uses an on-device decision model to match visible fields with supplied profile data, and types or selects the resulting answers in the real application. A WebFormDriver supports embedded WKWebView forms. The project converts CUA-S1-FORMS to Core ML and runs it through FluidAudio; it also includes laya-based typed decision models for choice, score, and yes/no-style questions. DocumentEntities can turn PDF or text files containing label-and-value lines into a profile, while a predetermined-answer sheet handles question-style fields outside the model's decisions. The repository states that processing stays on the machine and that the tool does not read résumés, reason about dropdown options, write free text, upload files, or click Submit unless enabled. FluidUse is licensed under Apache 2.0 and requires Accessibility access for its launching terminal.
AI Manager is a local-first desktop application for installing, updating, configuring, and repairing AI coding command-line tools on a user's computer. It provides a single interface for checking installed tools, managing versions, connecting tools to reviewed or custom HTTPS AI-service endpoints, and viewing the effective endpoint and environment-variable overrides without editing shell profiles or PATH files. Its sidebar includes software management, API endpoints, skills, MCP connections, global prompts, sessions, and settings. It installs skills from trusted GitHub catalogues or local ZIP files, supports stdio, HTTP, and SSE MCP servers, and searches local coding-tool sessions that can be resumed in a terminal. Tool behavior is controlled by a capability registry, and the application uses local signals for checks rather than claiming a process is healthy without evidence. The application is built with Tauri 2 and React 18 and is released under the GNU AGPL-3.0-or-later. It has no analytics or telemetry SDK, stores product data locally, and offers signed update verification and platform-specific installers. Provider credentials are currently stored in plaintext in the local database, backups, and SQL configuration exports. AI Manager began as a fork of CC Switch, with inherited portions retaining their original MIT licensing.
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.
jev-voice-browser is a Node application that controls a headed Chromium browser by voice or typed commands. It streams partial speech transcripts from the browser's Web Speech API to a Node server, which uses TypeSafe's Jev model to classify the intent, select a page element or site, extract candidate text and URL spans, determine whether the command is complete or addressed to the browser, and assess whether an action is destructive. Playwright then executes navigation, searches, typing, clicking, scrolling, history, and tab actions. The application sends the page URL, title, detected site, a compact snapshot of visible elements, and recent actions to Jev for each transcript update. Code—not the model—constructs URLs, copies text verbatim, and applies policy thresholds to decide whether to act, wait, ignore, request confirmation, or show numbered alternatives. Recent action context supports corrections such as reversing an action, rejecting a selected result, or choosing another candidate. It requires Node.js, Chrome or Edge for microphone input, Playwright's Chromium installation, and a TypeSafe API key. The server can launch a persistent-profile Chromium window or attach to an existing browser through CDP; it also supports headless operation and typed commands when no microphone is available.
reflex is an open-source local decision model for classifying tickets, documents, photos, and other state against typed questions with fixed answer choices. It runs the state through an open-weights model in one forward pass, branches each question independently, reads only the answer-label scores rather than generating free text, and returns probabilities for yes/no, choice, or ordered-score questions. It can read each question in multiple option orders and average the results to reduce position bias; optional temperature calibration adjusts confidence estimates for a target workload. The project provides a Python engine, an HTTP endpoint at /v1/systemone, GPU and Apple Silicon execution, an SGLang backend, a WebGPU browser demonstration, and optional LoRA training and distillation tools. The default serving configuration uses a frozen Qwen checkpoint, and the repository is licensed under MIT; model weights have their own licenses.
Laya is an open-source, Jev-compatible System-1 decision model package by Convai Innovations for running typed decision questions from Node.js and TypeScript through ONNX Runtime. It accepts a state such as a ticket, email, or JSON object and returns calibrated answers for choice questions with per-option probabilities, ordered score questions with a probability distribution and expected level, or yes/no statements with a probability of true. Questions in one call are batched into a single model run, and the package uses the same request and response shape as the Python reference implementation without requiring Python or PyTorch at runtime. The package downloads and caches ONNX model weights from Hugging Face by default, or can load a local ONNX bundle; it requires Node.js 20 or newer. The JavaScript package is MIT-licensed, while the Laya model weights are published under Apache 2.0.
DocJev is an open-source Python library, CLI, and local app for classifying and splitting PDF, DOCX, and PPTX files with user-written natural-language rules. LiteParse extracts page text locally, then the hosted Jev decision engine assigns document categories or identifies boundaries between component documents; optional LlamaParse tiers provide cloud OCR for difficult inputs. Classification returns a category, probabilities, and review flags. Splitting returns ordered categories and contiguous page ranges, with optional export of each segment as a PDF and review reasons for uncertain boundaries. DOCX and PPTX processing requires LibreOffice, and inference is not offline because Jev is a hosted service. The project is distributed under the Apache-2.0 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.
jeff is a self-hosted, MIT-licensed drop-in implementation of TypeSafe's jev System One API, powered by the GLiFormer encoder model. It accepts classification questions through a compatible SDK or the POST /v1/systemone endpoint and returns choice selections, ordered scores, and noul yes/no probabilities. The server supports CUDA, Apple MPS, CPU, and ONNX Runtime deployments, with batching, bearer-key authentication, rate limits, request limits, health and statistics endpoints, and deployment configurations for Modal. Its repository reports lower hosting costs than jev but weaker results on reasoning-heavy tasks.
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.
Veo is an AI video-generation engine that creates short video clips from prompts. The demonstrations describe it as better suited to slower, emotional scenes than to high-action sequences.
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.
Mobile MCP is an open-source Model Context Protocol server from Mobile Next for automating and scraping native iOS and Android applications on simulators, emulators, and connected real devices. It exposes a platform-agnostic set of MCP tools for device management, app installation and control, taps, swipes, text input, screenshots, screen recording, device logs, crash reports, deep links, orientation, location, and clipboard operations. The server primarily drives applications through native accessibility trees and structured UI-element data, falling back to screenshots and coordinate-based actions when required. It can run locally over stdio or as a Streamable HTTP server, and can use Mobile Next Cloud to reserve remote physical devices through the same tool interface. It is distributed as the `@mobilenext/mobile-mcp` npm package and requires platform tooling such as Xcode command-line tools or the Android SDK for device access.
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.
Interference Search is a research project and Python library for reasoning over explicit states rather than a single linear language-model transcript. It expands live branches in parallel, lets the environment execute their moves, merges branches that reach the same state, uses a trained judge to discard states unlikely to reach the goal, and advances the surviving frontier one level at a time. The method is classical and does not claim quantum speedup. The repository implements Countdown arithmetic search and program search, including move generation, exact solving, judge training, sandboxed program tests, behavioral merging, benchmarks, raw results, failed experiments, a research log, and the accompanying paper. Its reported experiments compare the approach with linear language-model reasoning and other search strategies; it also includes a one-line baseline and tools for reproducing the Countdown results. The package requires Python 3.10 or newer and runs with PyTorch. Language-model experiments use MLX on Apple silicon, while the core search, judge, and tests can run on other PyTorch-supported systems. It is distributed under the Apache 2.0 license.
BridgeClip is an open-source AI desktop app from BridgeMind that turns local videos or podcast, YouTube, and Twitch VOD links into captioned short-form clips. It downloads the source when needed, transcribes speech, uses OpenRouter to identify promising moments and plan the clips, reframes them to 9:16 or 16:9, and renders the results locally with FFmpeg and word-by-word captions. It supports smart face and screen-share framing, multiple caption styles, clip libraries and job tracking, and optional publishing or scheduling through Zernio. The app runs on the user's computer without a BridgeMind backend; provider keys and transcription or planning data are sent to the selected OpenRouter services, while rendering is local. macOS and Windows releases are provided, Linux development is supported, and the project is MIT licensed.
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.
jev-use is a macOS voice and text computer-use harness built on Jev. It reads the frontmost app's Accessibility tree rather than taking screenshots, sends the command, app and window names, visible targets, and recent actions to Jev, then selects and performs operations such as clicking, typing, pressing keys, scrolling, opening items, and arranging windows. After each operation it reads the Accessibility tree again and continues until the task is complete, blocked, or waiting; low-confidence or destructive actions stop for confirmation. The app supports hold-to-talk, typed commands, hands-free listening, and an optional “Hey Jev” wake phrase, with speech handled by Apple Speech. It requires macOS 14.2 or later and Xcode, has no external dependencies, and stores the TypeSafe API key in the macOS Keychain.
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.
product-film is a Claude Code skill for creating product films in Remotion, including landing-page loops, launch videos, promos, and demo reels from a product's real components, design tokens, logo, and stated claims. It first inspects the product's design rules, tokens, components, live site, logo, and claims, then interviews the user about the film's duration, placement, music, features, and visual ingredients. It records the resulting brand kit in videos/BRAND.md, creates a beat sheet, analyzes the music's beat grid, builds time-based Remotion scenes, and supports review through style frames, stills, contact sheets, and a draft render. The final workflow renders a 240 fps master with motion blur and can produce a muted loop, a music version, a WebM file, and a poster; verification scripts decode the outputs and check colors, duration, and loop continuity. It runs in a local Claude Code toolchain rather than the Claude chat apps, requires Node.js, Bun, and uv, and is distributed under the MIT license for its own text and code.
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.
Fellow is an AI meeting assistant that records meetings through a bot or desktop and mobile apps, then produces transcripts, summaries, decisions, topic-based notes, suggested action items, and meeting briefs. It organizes searchable meeting records and follow-up work, with integrations for CRM, project management, documentation, and automation tools. The service is positioned for enterprise and regulated teams and provides security and compliance controls; its site states that customer data is not used for AI training.
ZoomInfo is a go-to-market platform for B2B sales, marketing, recruiting, and revenue-operations teams. It combines business contact and company data with firmographic, technographic, and intent signals to help identify target accounts, estimate revenue potential, find decision-makers, and prioritize outreach. The platform provides people and company search, account intelligence, AI-assisted insights, lead and data enrichment, account scoring, territory management, CRM synchronization, and workflow automation. Its data is gathered through proprietary technology, machine learning, public sources, and a contributory network, and the service integrates with CRM, sales-engagement, and marketing platforms.
ChatGPT voice is a voice-based ChatGPT interface described in the video as accepting spoken instructions during activities such as biking. In the cited use case, it categorized emails, applied labels, replied to messages, and sent calendar invitations.
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.
GPT-6 Sol and Luna are two OpenAI models designed for different cost and capability balances. Sol is aimed at harder tasks, while Luna targets high-volume, lower-cost use. The models support adjustable reasoning and discounted prompt-cache usage.
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.