1,038 tools and products — trending open source, and what gets used in AI and other work.
LibreChat is an open-source, self-hosted AI chat platform that provides a ChatGPT-inspired interface for connecting to major AI providers and custom OpenAI-compatible endpoints. It supports model switching, multimodal file interactions, web search, speech-to-text and text-to-speech, image generation, conversation search, presets, branching, resumable streams, and a sandboxed Code Interpreter for languages including Python, JavaScript/TypeScript, Go, C/C++, Java, PHP, Rust, and Fortran. Its agent system supports no-code custom assistants, community-shared agents, MCP servers, tools, file search, code execution, reusable SKILL.md instruction bundles, subagents, and an Agent Management API. Agents can optionally use attached workspaces to inspect, search, edit, and run commands in bounded environments. The platform also provides generative UI artifacts, including React, HTML, and Mermaid content, plus custom actions and integrations with providers such as Anthropic, AWS Bedrock, OpenAI, Azure OpenAI, Google, Vertex AI, Ollama, Groq, Mistral, OpenRouter, and others. LibreChat includes multi-user authentication through OAuth2, LDAP, and email login; browser-based administration of users, groups, roles, and configuration; role-based permissions; observability through OpenTelemetry and Langfuse; Redis-backed synchronization for scaled deployments; and Docker Compose deployment options. It is built in public and intended for local or cloud self-hosting.
security-audit is a Cloudflare coding-agent skill that orchestrates multi-phase security audits of codebases. It uses reconnaissance to map architecture, trust boundaries, input surfaces, prior evidence, and deterministic coverage; assigns isolated agents to coverage-led hunting; sends each unique candidate to a fresh verifier; and records confirmed, needs_validation, and rejected results in machine-readable findings.json validated against a report schema. Independent agents verify final source claims, after which the skill derives target-neutral reports and coverage records. It can be installed with the Skills CLI and requires a tool-using coding agent with parallel sub-agent support, Node.js for its validators, and an OS-enforced sandbox for target-controlled execution. The repository is licensed under MIT.
Knowledge Work Plugins is an open-source repository of role-specific plugins for Claude Cowork and Claude Code. Each plugin bundles domain skills, MCP connector configuration, slash commands, and, where applicable, sub-agents for workflows such as productivity, sales, customer support, product management, marketing, legal, finance, data, enterprise search, and biomedical research. Plugins use file-based Markdown and JSON rather than application code, infrastructure, or build steps; users can install them through Cowork or the Claude Code plugin marketplace and customize their connectors, company context, and workflow instructions.
Supervision is an open-source Python toolkit from Roboflow for building computer-vision applications. It provides model-agnostic building blocks for loading, converting, splitting, merging, and saving datasets; connecting classification, detection, and segmentation models; representing detections; annotating images and video; and performing tasks such as tracking and real-time zone counting. The package supports connectors for libraries including Ultralytics, Transformers, MMDetection, and Roboflow Inference, and is installed with pip in a Python 3.10-or-later environment.
Cline is an open-source AI coding agent developed by Cline Bot Inc. It is available as a CLI assistant, VS Code extension, JetBrains plugin, native macOS and Windows desktop app, and SDK. Cline reads project structure, edits files across a codebase, runs terminal commands, observes build and test output, and can correct issues such as missing imports, type mismatches, syntax errors, and failed tests. Its Plan and Act modes separate codebase exploration and planning from execution; edits and commands can require human approval, with checkpoints for reviewing or reverting changes. The CLI supports interactive and headless operation for scripting and CI/CD, while the SDK exposes the shared agent engine for custom tools, plugins, lifecycle hooks, multi-agent teams, scheduled agents, connectors, and MCP servers. The project supports models from multiple providers and OpenAI-compatible endpoints, including local-model runtimes, and can connect agent sessions to messaging platforms such as Telegram, Slack, Discord, Google Chat, WhatsApp, and Linear. It is distributed under the Apache 2.0 license.
Visiby is an AI citation-intelligence and visibility platform from FNA Technology. It samples buyer prompts across ChatGPT, Claude, Perplexity, Gemini, and Google AI Overviews, then parses model answers to measure brand mentions, citation share, competitor visibility, and the URLs and passages being cited. Its workspace includes prompt and citation explorers, brand-entity analysis, competitor intelligence, recipe intelligence for identifying cited page elements, and a citability-focused site audit. It combines prompt results, lost-citation signals, and competitor citation patterns into prioritized content, schema, and technical action plans with supporting evidence and estimated impact.
Nimble Web Search Agents are domain-specific web research agents from Nimble that perform self-learning search, crawling, structured extraction, dataset enrichment, and web monitoring. They use auditable Search Plans, a proprietary index, and memory that adapts to a use case after each run to retrieve targeted data from the live web, including JavaScript-rendered pages, without requiring an LLM to parse raw pages. Nimble exposes these capabilities through APIs for search, complex research workflows, dataset building, monitoring, extraction, and crawling.
BrowserSkill is an open-source browser-automation bridge for AI agents, consisting of the `bsk` CLI and daemon plus a Chrome or Microsoft Edge extension. An agent sends browser tasks through the CLI; the local daemon routes them over WebSocket to the extension, which performs actions in a separate visible Agent Window. Agents can use existing browser login state, borrow an already open tab only with explicit approval, and request human intervention for captchas, confirmations, or other user-only steps. It supports shell-capable agent harnesses, macOS, Linux, and Windows, and is distributed under the MIT license.
BG0 is an open-source background-removal tool that runs locally in the browser and produces transparent PNGs without uploading source images. It uses WebGPU when available and falls back to WebAssembly, downloading and locally caching a pinned BiRefNet ONNX model selected for the available hardware. The project includes the BG0 web application and the @bg0/browser library, which handles capability detection, model loading and caching, preprocessing, ONNX inference, mask postprocessing, alpha compositing, progress reporting, cancellation, and errors. It requires no account, API key, backend, server inference, billing, usage limit, or analytics transmission of image contents or metadata. The source is licensed under Apache License 2.0; model weights retain the licenses listed in the repository's third-party notices.
ToolReplay is a dependency-free Python CLI for auditing recorded AI-agent tool-call transcripts without executing the tools again. It strictly parses JSON Lines records, compares repeated calls and their canonicalized responses to detect non-determinism and redundant calls, checks tool names against a declared permission scope, and produces deterministic, timestamp-free reports suitable for CI checks and Git diffs. It can seal transcripts into a SHA-256 hash chain, verify the chain for edits or reordered records, replay a session against its recorded responses, and report permission overreach. It requires Python 3.11 or newer, has no third-party runtime dependencies or network access, and is distributed under the MIT license. Its scope checks are name-based, sealing is tamper detection rather than a signature, and replay only detects issues represented in the recorded transcript.
Design Studio AI is an open-source, agent-first design workspace for humans and AI agents. It supports web interfaces, slides, reports, wireframes, 3D scenes, and timeline videos; users start from a brief or template, inspect a preview, revise through chat or a manual editor, and work together on the same versioned document. The workspace provides structured flex/grid layouts, reusable design systems, 2D character motion, editable 3D scenes, BYOK text/image/speech/music/video generation, and exports including JSON, HTML, SVG, PNG, PDF, PowerPoint, WebM, GLB/glTF, React prototype ZIPs, and authorized Google Slides. It exposes REST, authenticated MCP, experimental WebMCP, and a CLI for agent access, and can run on Cloudflare or be self-hosted with Docker and persistent SQLite/files. The repository is distributed under the MIT license.
Claude for Siri is an experimental, open-source macOS menu bar app and App Intents model-delegation provider that exposes a signed-in Claude Code account through macOS Spotlight and Siri. It is an independent implementation, not an official Apple or Anthropic integration. A sandboxed provider extension sends text requests over authenticated localhost NDJSON to a Swift bridge in the host app, which invokes the Claude Code CLI in a temporary directory with tools, MCP servers, Chrome integration, and conversation persistence disabled. The resulting text streams into Apple's native response UI; each request starts a fresh conversation. Writing Tools support for selected text is implemented but not verified in the native UI, and the provider does not handle images, attachments, device actions, or Siri access to mail, contacts, messages, or the semantic index.
RSIAgent is an open-source, training-free multi-agent framework for recursive self-improvement in unfamiliar digital environments. It uses a Curriculum Agent, Actor Agent, and Verifier Agent while keeping model parameters fixed. Its learning loop has two stages: broad recursive self-exploration, in which agents perform diverse projects and consolidate verified experience, followed by deep recursive self-exploration, in which the Curriculum Agent selects focused practice around gaps and fragile successes. The Actor Agent interacts with software through executable Python or Bash programs and visual observations; the Verifier Agent independently checks task requirements and resulting environments. Procedures, scripts, successful experiences, and failure lessons are stored in persistent memory, which is frozen and reused for downstream task execution. The repository provides runtimes and benchmark integrations for OSWorld-V2 and Agents' Last Exam, along with setup, smoke-test, batch execution, reporting, recovery, and validation utilities. It requires Python 3.12 and a Linux host with Docker and /dev/kvm for the documented benchmark runs, and is licensed under Apache License 2.0.
gap-trap is an installable coding-agent skill that reads a repository and generates repository-specific contracts, checks, and quality gates for AI-written code. Contracts document the approved way to handle areas such as HTTP, logging, settings, and authentication; gates fail commits or CI runs when those rules are violated. Its Proven Red CI job runs each new test against the old code and rejects tests that pass without the change, while ratchets track known problems such as lint backlogs or oversized files and allow their counts to decrease but not grow. It also creates playbooks from project lessons and installs the related slop-mop skill for agent-generated documentation, commit messages, and pull-request bodies. Node and Python repositories receive gates inside their test suites; other listed languages use shell-based gates requiring git, grep, awk, and the project test command. It is installed through the skills CLI or by copying the skill into Claude Code or Codex skill directories, and provides setup and refine commands. The repository is MIT-licensed.
Panel is a research workspace that places an AI-agent chat alongside files, PDFs, and live Jupyter notebooks. The agent can read and write files, run notebooks against a real kernel, create scratch data, and edit the same notebook as the user; configurable panes can also display images, data, code, chats, and custom viewers or apps. It supports workspaces with separate chats and saved layouts, background commands, and literature reviews. The early build currently has full support for Claude Code, with optional OpenAI API support for chat and tools; it is distributed under the MIT license and runs locally with Node, pnpm, uv, and Python.
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.
BirdNET-Go is a tool that identifies bird species from environmental audio.
H3 Max Turbo is a faster variant of fal's H3 Max generative video model, which fal post-trained from MiniMax's open-weight video model. It is designed to generate a five-second video in approximately 1.5 seconds, with a small quality tradeoff compared with H3 Max. The model's speed supports experiments with real-time and continuous video generation.
H3 Max Director is a public AI model for action-controlled continuous video. It maintains memory of previous scenes and accepts live prompt-based direction while video is running, enabling control over elements such as camera movement, lighting, characters, motion, and lip sync. It is described as fal's post-trained version of MiniMax's open-weight video model, combined with systems and hardware optimization for real-time generation.
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.
GitDiagram is a web application that turns public or private GitHub repositories into interactive architecture diagrams with links back to the source files and directories. It retrieves a repository's default branch, tree, README, and bounded, integrity-checked source excerpts through the GitHub API; an OpenAI or OpenRouter model produces a source-grounded overview and graph, whose groups, nodes, edges, shapes, labels, and paths are validated against the repository. A deterministic compiler converts the validated graph to Mermaid, while the browser sanitizes and renders the result and can export Mermaid source or a PNG. Successful diagrams are persisted for later reopening, and private-repository access uses a GitHub token supplied for the relevant request rather than embedding the token in public links.
Vmake Labs is an AI social-video studio from Vmake, formerly called Vmake AI, for generating, editing, enhancing, and optimizing video and image content. It provides video and image enhancement, video upscaling, watermark and unwanted-element removal, video background removal, noise reduction, caption and hook generation, video translation, AI avatars, product showcases, and UGC video generation. Its workflow turns product images, existing footage, or other ideas into social content for platforms such as TikTok, Instagram Reels, YouTube Shorts, Shopify, and Amazon Inspire. The product offers free access and credits, with paid upgrades available; a demonstrated video-enhancement workflow used Master mode at 4K resolution.
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.
fast-jev-compaction is an npm library and Claude Code plugin that compacts tool-call history without rewriting the original text. It pairs each tool call with its result, sends the conversation state and questions about each non-pinned call to Jev, and then keeps the call and result, keeps only the call while truncating the result, or removes both according to Jev's scores. Recent messages and the first message are pinned; state fitting progressively truncates inputs, abridges long text, collapses older messages, and reduces old tool calls to one-line records so requests fit within configured token estimates. User and assistant text is never removed or shortened in the returned transcript, and retained content stays verbatim. The package exposes compaction, decision, batching, state-fitting, and transport-building functions, while the Claude Code hook replaces built-in compaction and falls back to Claude Code's summary when Jev fails or reduction is insufficient. It uses the TypeSafe API by default and requires a TypeSafe API key.
jev-trader is an AI market-making bot for the Kuru MON-USDC order book on Monad. A TypeSafe Jev model observes the order book once per block and predicts whether to buy or sell over a configurable future horizon; each block, the bot cancels its resting orders and submits a post-only limit order one tick inside the touch, aiming to earn the spread when a taker fills it. Its hot loop reads the book with one RPC call and submits the transaction with one asynchronous raw-transaction call, leaving receipt processing, fee estimates, and vault checks off the critical path. It records block decisions, quotes, fills, positions, and profit-and-loss data, and exposes snapshots, history, and server-sent events through a Bun server. If the model misses the block, it holds and posts nothing; position or margin limits can redirect a quote to the opposite side. The repository supports a dry-run mode with simulated fills and a mock momentum heuristic, or live Jev decisions using a TypeSafe AI API key and private key. It includes a deployed dry-run dashboard endpoint and can be run with Bun.
Jev Search is a web search application built by Search1API that uses TypeSafe's Jev to interpret plain-language requests, select search terms, sources, and time ranges, and rank results. It queries general and vertical search engines concurrently, merges results by URL, engine agreement, original rank, and Jev relevance scores, and returns links and snippets with editable filters rather than generated answers. The application streams results as search lanes finish, reports failed sources separately, and can be installed as a browser app; it requires a network connection for searches. The open-source application is MIT licensed and can be self-hosted on Cloudflare Workers with Search1API and a Jev provider such as TypeSafe, Vercel AI Gateway, or Cloudflare Workers AI.
An open-source tax-document page classifier built with TypeSafe Jev. It extracts text from PDF pages, then uses decision-model requests to classify each page by form and page kind, returning probability distributions, a form identifier, confidence scores, and a gate indicating whether the result meets the configured confidence threshold. Its generated JSON criteria file describes IRS forms using data extracted from IRS form PDFs; a second request handles schedules for selected corporate and foreign forms. The package includes PDF helpers based on Poppler, supports text-layer input, and requires a TypeSafe API key for the Jev backend. It does not train or host a model, is limited to English federal-form classification, requires OCR for scanned pages, and is distributed under Apache-2.0 with separate licensing for IRS-derived data.
kev is an open-source, local Jev-inspired decision model from Jared Palmer. It runs on a laptop and accepts a document or other state plus typed questions, returning calibrated probabilities rather than generated text. It supports yes/no (noul), multiple-choice, and ordered-score questions. The model uses a LoRA adapter and a readout head on a Qwen base model. It packs the state and all questions into one sequence, applies a block-causal mask so each question can see the state but not sibling questions, and performs one prefill pass without decoding. A pointer head scores each option against the question's decision token and applies softmax; the head is trained with cross-entropy on labelled outcomes. The local server exposes a TypeSafe System One-compatible API at POST /v1/systemone, allowing the official TypeSafe SDK to connect by changing its base URL. It also provides model information, option-order permutation, and separate-pass comparison endpoints, plus a local playground. The repository includes 0.5B, 0.6B, 4B, and 8B model checkpoints and recipes for local or Modal-based training and evaluation. Serving is tested on Apple Silicon, with larger checkpoints requiring bf16 on a 32 GB Mac. The server has no authentication and is intended for local use. The project is licensed under Apache-2.0; base models and datasets have separate licenses.
NanoJev is an open-source 0.6B parallel-decision model and training pipeline based on Qwen3-0.6B. It accepts states, questions, and candidate sets in a single forward pass and returns complete probability distributions without output-token decoding. Shared decision heads support dynamic-choice distributions over supplied candidates, Boolean proposition probabilities, and ordered score levels with expected values. The repository includes data generation, distribution-loss training, evaluation, persistent serving, and browser replay tools. Its game demonstrations combine model judgments with controller code: maze controllers ask local safety questions and track collisions and explored paths, while Snake controllers filter immediate collisions, plan toward visible food, and use the model to break ties between remaining actions. Checkpoints and datasets are distributed through Hugging Face, and the service exposes repeated batched evaluations through a local HTTP endpoint.
ABot-Recon is a streaming 3D-reconstruction model and inference tool for reconstructing long video streams from video frames alone. At each step, it caches key-value features from the preceding 11 frames, predicts a point map in the current camera coordinate system, estimates the adjacent relative camera pose, and composes those poses sequentially into a global trajectory and point cloud without persistent learned long-range memory. It can output camera poses, relative poses, local and world point maps, colors, confidence maps, and run metadata. An optional loop-closure backend retrieves candidate revisited-frame pairs using DINOv2-SALAD descriptors, predicts relative-pose constraints with ABot-Recon, and refines the trajectory through sparse pose-graph optimization. The repository provides Python and command-line interfaces, a public model checkpoint, a demo, evaluation code, and visualization utilities. The released configuration targets Linux, Python 3.10 or later, PyTorch 2.5.1, and CUDA 12.1; source code is licensed under Apache License 2.0, while the model weights have separate terms in MODEL_LICENSE.md.
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.
Laya is an Apache-2.0 Python package and encoder-model decision engine developed by Convai Innovations. It accepts text or JSON state and evaluates typed questions in a single forward pass, returning categorical choices with probabilities and confidence, ordinal scores, or calibrated Boolean probabilities rather than generated text. Its stated uses include routing, ticket triage, prompt-injection detection, moderation, phishing detection, and churn-risk classification. Laya includes English, multilingual, and typed-decisions checkpoints, plus a router that selects a checkpoint using explicit settings, detected script, and best-effort language detection. The checkpoints use reinforcement learning against strictly proper scoring rules (RLCD); the project also provides fine-tuning and temperature-calibration workflows. The multilingual checkpoint is intended for more than 100 languages, while the repository cautions that the base models can perform near chance on some zero-shot typed-decision tasks and that large choice sets are constrained by the option-token budget.
TypeSafe Mario is an experimental controller that uses TypeSafe's Jev model to play the original Super Mario Bros. from structured emulator state rather than screenshots. A parser converts emulator telemetry and RAM into object-centric JSON describing Mario's motion and jump trajectory, nearby enemies, terrain, response timing, recent control results, and episode progress; Jev then selects one of a small set of legal NES controller actions, after which the emulator advances and the loop repeats. The system also runs separate Choice, Noul, and Score judgments over each state: Choice selects the next controller macro, Noul estimates whether a forward jump is useful, and Score measures immediate danger for visualization. It provides a demo state inspector, a live dashboard with action probabilities, confidence, latency, jump probability, danger score, reward, and parsed state, plus JSONL decision logs containing model state, debug state, timing, and game outcomes. It requires Python 3.13 or newer, a TypeSafe API key, and a lawful local emulator and game setup; the repository does not include the Nintendo ROM or other copyrighted game data.
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.
Project Titania is a from-scratch large language model system covering a decoder-only transformer, compiler, instruction-set architecture, ISA simulator, and planned GPU hardware. It runs Qwen3-0.6B and expresses the model as GPU kernels for matrix multiplication, normalization, attention, and activation functions. The compiler lowers those kernels into Titania ISA programs, while the ISA simulator executes the instructions as the reference implementation of their behavior. Running `titania run --device isasim` compiles each model operation into a Titania kernel for its shape and displays the simulated kernel execution, including a warp's current disassembly. The repository also provides a CLI that can run the model on the CPU or simulator and includes a bash tool whose commands run without confirmation. The project is written to keep each layer readable and uses the MIT license. Its hardware layer is an RTL GPU design planned to progress through RTL simulation, FPGA synthesis, and eventual silicon; the current end-to-end model execution described by the repository uses the CPU and ISA simulator.
expo-gpt-live is an Expo SDK 57 voice-app template for iPhone that connects GPT-Live 1 with web search, a weather tool, selectable voices, and six AI Elements Persona variants. Users can speak during an AI reply, change the animated persona during a call, and keep a conversation running in the background on iOS. The project includes a local server that generates an app access token and relays requests using an OpenAI API key kept server-side. It uses native WebRTC and Rive components, so it requires a native build rather than Expo Go; the repository documents development on macOS with Xcode and deployment to a connected iPhone, as well as web and Android commands. Background calls are implemented on iOS only, and calls end after ten minutes. The repository is MIT-licensed. Its setup requires Node.js, macOS with Xcode, and an OpenAI API key with access to GPT-Live 1; the README advises adding authentication before exposing the backend publicly.
An Anthropic reference release containing 36 drop-in inference-optimization kits for open protein- and genomics-machine-learning tools, covering structure prediction, cofolding, binder and sequence design, protein-language-model inference, and genomic prediction. Each kit carries a pinned upstream release in a stock directory and applies optimizations under a named mode without changing the upstream calling interface. Modes include off for the unmodified upstream tool, exact for identical outputs with faster inference, fast for documented numerical differences, and big for lower peak GPU memory; some kits also support splitting a prediction across multiple GPUs. The kits share runtime code for mode resolution, determinism, memory handling, multi-GPU execution, and GPU kernels, and can be installed through Docker, Apptainer, or a pinned Python environment. The repository is a non-maintained reference release accompanying Anthropic's biomolecular-modeling blog post; its original code is under Apache License 2.0, while the carried upstream projects and model weights have their own licenses and terms.
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.
Simple Jev is an open-model classifier and scoring server from Featherless AI. It accepts shared context or chat messages plus questions, then reads the model's next-token logits for predefined answer labels instead of generating a prose or JSON completion. The server constructs JSON responses for choice classification, ordered rubric scores, and truth or support judgments, including confidence and label distributions. Its Hugging Face Transformers implementation identifies the exact common token prefix across questions, evaluates that prefix once, reuses its KV cache for question-specific suffixes, and batches the suffixes before scoring the allowed answer tokens. The response-scoring code normalizes the selected logits; shared context is counted once for usage purposes, and no output tokens are generated. The API provides non-streaming /v1/classifier and /v1/systemone endpoints, with local execution supported through Python, PyTorch, and Transformers. A public demo API is available, while production deployments can use Featherless paid plans or run the server themselves. The repository also includes RFDT, which fine-tunes models directly on allowed answer-token logits using the same prompt structure.
LocalJev is a TypeScript service that provides a local Jev-compatible decision API for applications using TypeSafe's typed decision interface. It exposes a POST /v1/systemone endpoint and translates typed Jev questions and application state into classification prompts for an OpenAI-compatible DiffusionGemma inference server. The service validates and retries malformed JSON, normalizes probability vectors, calculates Jev-compatible choices, expected scores, and entropy-based confidence, and returns the standard Jev response shape. Its probabilities are model-generated or self-reported rather than read directly from model logits, so the repository advises evaluating calibration for the intended workload. It runs with Bun and can use oMLX as the local inference server; the default LocalJev address is http://127.0.0.1:8080.
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.
perch is a semantic code-linting CLI that checks source code against plain-English rules using Jev. It scans files and reports ranked findings with line numbers, severity, problem and method labels, and confidence scores; issues can be inspected individually with `perch issues` and rechecked after fixes with `perch check`. Custom rules are defined in file-scoped `perch.yaml` configuration using selectors such as `where` and `each`, minimum confidence thresholds, and an `ensure` statement. It also provides setup commands for Claude Code, Codex, pi, and Cursor, and can gate builds in CI.
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.
json-render is a generative UI framework from Vercel Labs that converts natural-language prompts and structured JSON outputs into interface specifications constrained by a developer-defined catalog of components, actions, schemas, and data bindings. The catalog generates the AI system prompt and acts as a guardrail; specifications are validated against the catalog and rendered progressively through a streaming compiler. Components can use state expressions, conditional visibility, computed values, templates, actions, and state watchers. The framework provides renderers and adapters for React, Vue, Svelte, Solid, React Native, Next.js, TanStack Start, terminal UIs, Remotion video, React PDF, React Email, SVG/PNG images, and React Three Fiber, along with optional shadcn/ui components, devtools, state-store adapters, MCP Apps integration, YAML support, and code-generation utilities.
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.
Bittensor is a decentralized-AI blockchain and infrastructure project. Its network supports robotics companies, early AI startups, and other projects, with the infrastructure intended to benefit from activity across those projects.
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.
AutoGluon is an open-source Python machine-learning library for automated modeling of tabular data, time series, and other data types. It trains end-to-end predictive models by selecting and combining suitable algorithms, including classic machine-learning models, ensembles, and foundation models; its tabular API can fit a predictor from a training file and generate test-set predictions with a few lines of code. The library supports Python 3.10–3.13 on Linux, macOS, and Windows, with optional GPU support, and is licensed under Apache 2.0.
mitra-finetune is a Python package for fine-tuning and running inference with second-generation Mitra v2 tabular foundation-model checkpoints. It supports classification and regression through the `MitraFinetune` API, including `fit`, `predict`, `predict_proba`, and distributional regression outputs. Each fit performs a 50-step full fine-tuning run through AutoGluon's eight-fold bagging wrapper. The package uses capped, optionally class-balanced in-context support for large tables, narrows wide tables with top-K feature selection or truncated-SVD projection, and uses hierarchical label decomposition for classification problems exceeding the checkpoint's native 10-class head. Regression is represented as classification over 1,000 target bins, with predictions returned as point estimates or predictive distributions. The package requires Python 3.11–3.13, a CUDA GPU, AutoGluon with the Mitra extra, and the TabArena execution wrapper. It uses checkpoints hosted on Hugging Face, including `autogluon/mitra-classifier-2` and `autogluon/mitra-regressor-2`; FlashAttention is optional. The project is distributed from its Hugging Face repository and can be installed from a cloned checkout.
Mitra-v2 Classifier is a tabular foundation model from AutoGluon and Amazon for classification tasks. It is pretrained entirely on synthetic datasets sampled from random classifier priors, including a Hybrid SCM prior, rather than on real-world datasets. The model uses a 12-layer 2D Transformer with attention across both rows and columns and incorporates in-context learning. Its recommended recipe fine-tunes 50 steps on a user's table and bags eight model copies for prediction; it can be run through the mitra-finetune package or used as a Mitra model in AutoGluon Tabular. The repository describes it as the second generation of Mitra, with a longer context, more features, and an improved optimizer than Mitra-v1. The weights are distributed on Hugging Face under the Apache-2.0 license and require a CUDA GPU for the documented fine-tuning and eight-fold bagging recipe.
Mitra-v2 Regressor is a tabular foundation model from AutoGluon for regression tasks. It is pretrained entirely on synthetic datasets sampled from mixed random-regressor priors, including a Hybrid SCM prior, and uses in-context learning with a 12-layer 2D Transformer that attends across rows and columns. Regression is formulated as classification over 1,000 target bins: the model predicts a distribution for each row, whose mean provides the point prediction and whose probabilities can also produce quantiles and probabilistic metrics such as CRPS. Using the accompanying mitra-finetune package, the model is fine-tuned for 50 steps and bagged across eight copies on a CUDA GPU. It accepts tabular features and regression targets and returns point predictions or full predictive distributions. The weights are distributed through Hugging Face under the Apache-2.0 License; the package is required because standard AutoGluon expects the scalar head used by Mitra-v1 rather than Mitra-v2's distributional head.
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.
Handy is a free, open-source, cross-platform desktop speech-to-text application that transcribes speech locally and inserts the resulting text into the active text field. A configurable keyboard shortcut starts recording in hold-to-talk or toggle mode; Handy filters silence with Silero voice activity detection, transcribes with local Whisper or Parakeet models, and pastes the result into the application in use without sending audio to the cloud. It runs on Windows, macOS, and Linux, supports Whisper models with GPU acceleration when available and the CPU-optimized Parakeet V3 model with automatic language detection, and provides CLI controls for recording and startup behavior. Linux text input may require tools such as xdotool, wtype, or dotool, and Wayland support has stated limitations. The project is distributed under the MIT License, although its name, logo, icon, and brand assets are not open-source.
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.