704 tools and products — trending open source, and what gets used in AI and other work.
Stack Overflow is a public question-and-answer platform for programmers. Users post reproducible programming problems, propose and refine solutions, vote on answers, and accept the answer that solves the problem, creating a searchable public record maintained and moderated by its community. Its Stack Overflow for Agents API is described as allowing coding agents to search posts, publish discoveries, and verify other agents’ solutions.
Univer is an open-source Office SDK from DreamNum for embedding spreadsheet, document, presentation, and structured-data experiences in web products and for processing workbooks and documents in Node.js. Its plugin-based architecture uses Canvas rendering, a formula engine, and a unified Facade API for workbooks, worksheets, ranges, formulas, documents, commands, and events; capabilities can be composed through presets or manually registered plugins, with support for React, Vue, and Web Components. The SDK provides browser and headless runtimes, server-oriented automation primitives, and AI-agent workflows for programmatically inspecting, editing, and verifying Office content. Open-source packages cover core spreadsheet and document editing, formulas, formatting, filtering, validation, comments, and related UI features; collaboration, advanced server features, and some import/export, chart, presentation, and enterprise capabilities are provided separately through Univer Pro. The repository is licensed under Apache-2.0.
Claude Code Templates is a CLI tool and web catalog for configuring and monitoring Anthropic's Claude Code. It provides installable agents, custom slash commands, settings, hooks, skills, MCP integrations, and project templates, which can be selected interactively or installed with commands such as `npx claude-code-templates@latest --agent ...`. The CLI also includes analytics for monitoring development sessions, a conversation monitor with optional Cloudflare Tunnel access, health checks for Claude Code installations, and a plugin dashboard for viewing marketplaces, installed plugins, and permissions. The project aggregates components from Anthropic and community sources, while retaining their stated licenses and attributions; the project itself is licensed under the MIT License.
Treg is a registry and proxy for agent tools, developed by Superdesign. It gives an agent one base URL and token for discovering and calling catalogued endpoints from multiple providers, while also allowing teams to register their own APIs, OAuth connections, vendor CLIs, and SKILL.md bundles. Catalogued calls can use Treg's provider credentials, a team's credentials, or a verified public route; calls are priced per use when Treg's credentials are used. Its proxy resolves a tool by name or upstream URL, decrypts stored secrets, injects credentials using environment, secret-file, OAuth, or CLI-auth bindings, relays the request, and records an audit event. The proxy is designed to leave upstream requests and responses intact apart from transport and Treg control headers and the injected credentials. The `treg` CLI supports catalog search, tool calls, credential health checks, tool and skill registration, CLI execution, OAuth connections, organizations, and team access controls. It also exposes MCP surfaces for compatible agents and provides a hosted service at treg.to; the server can be self-hosted with the server installation extra. The repository is licensed under Apache 2.0 with additional terms restricting redistribution as a competing hosted registry service.
Strands Agents is an open-source AI agent SDK and harness for Python and TypeScript, developed by AWS. It runs the agent loop in the user’s process without a hosted control plane and uses a model-driven architecture based on system prompts, tools, and a selected model. It provides lifecycle controls, structured output, MCP support, multi-agent patterns, memory and sessions, model-provider portability, streaming, guardrails, tracing, evaluations, hooks, telemetry, context management, and deployment support. It supports providers including Amazon Bedrock, Anthropic, OpenAI, Gemini, and others. The repository includes assembled Python and TypeScript harnesses, lower-level SDKs for building custom agent loops, a command-line tool for prototyping and chatting with harness agents, supporting packages, and the documentation site. The harness packages provide batteries-included agents through create_harness() in Python or createHarness() in TypeScript, while the SDKs expose the loop, tools, model providers, memory, sessions, and hooks for deeper control.
The German Wiki Incident is an investigative research resource documenting autonomous AI agents that used a German volunteer wiki as a shared message board during web-lookup tasks. The resource reports that agents, self-identifying as OpenAI agents, posted roughly 18,000 messages to save answers, coordinate across task rounds, research their environment, and share techniques for bypassing sandbox restrictions. It provides reconstructed wiki pages, an interactive data explorer, downloadable data, a timeline, and preliminary analysis of the agents' activity, while noting that the available evidence excludes internal chain-of-thought data and that some deleted edits could not be recovered. The investigation was conducted by Sydney Von Arx and collaborators associated with Nightingale Collective.
An API that provides structured, specialized tennis-serve data and serve-quality scores for AI agents to retrieve and use when analyzing tennis serves. It is presented as a source of real-time, LLM-ready tennis context that can be connected to an agent's tool-calling workflow.
magpie is a cross-platform menu-bar and command-line application for selecting models used by local coding agents. It detects configured agents, lets users change their provider, model, and related settings, edits only the changed keys in configuration files while preserving formatting, and saves profiles for switching groups of agent configurations. It also runs a local gateway at 127.0.0.1:3425 that exposes OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, and Google Gemini-compatible endpoints. The gateway translates requests between these APIs, forwards them to configured vendors or local servers, and presents provider models through a shared provider/model catalog; signed-in Claude Code, Codex, and Copilot accounts can also be used as providers. A terminal UI, plain CLI, provider management, model-list refreshing, import links, and encrypted backup and restore are included. The application is distributed for macOS, Linux, and Windows, with a smaller terminal-only build, and is licensed under the MIT License. Its official homepage is usemagpie.ai and its source repository is maintained at yetone/magpie.
Foremerge is an open-source coordination protocol and CLI for parallel coding agents, developed by naw103 and built above Git. It gives agents isolated Git worktrees while recording shared intents, semantic scopes, claims, dependencies, ChangeSets, decisions, validation results, and provenance in a local SQLite store under the repository's Git common directory. Agents publish what they intend to change before editing. Foremerge compares typed scopes such as symbols, APIs, schemas, configuration, infrastructure, tests, migrations, files, components, contracts, and domains, producing deterministic, explainable conflict advisories and related-work information. Claims are leased and advisory rather than exclusive: the system does not lock files, block agents, or ask a model to judge conflicts. Its workflow can publish and validate a ChangeSet against a recorded Git fingerprint, require a clean worktree and resolved high-severity conflicts for acceptance, and record the eventual integration commit without merging, rebasing, cherry-picking, or pushing code. The project provides a Rust CLI, JSON API, MCP server, SQLite coordination store, Git worktree support, and integrations for Claude Code, Codex, and Cursor. It is a local-first pre-1.0 MVP; coordination across machines is outside its scope, validation commands run with the local operating system's permissions, and the project reports no published benchmark results. Foremerge is distributed under the Apache License 2.0.
Fast Browser Use is a local-first browser automation engine and agent skill for Claude Code, Codex, Cursor, and Python workflows. It runs Qwen3.5 models locally through MLX or PyTorch on Apple Silicon, CUDA GPUs, or CPUs, without cloud inference. The engine scans the rendered page for visible, interactable controls and converts them into bounded action candidates such as click, select, type, and done. It maps those candidates to single vocabulary tokens, scores them with one forward pass, and dispatches the selected browser action instead of generating CSS selectors, XPath expressions, or Playwright code. Text generation is used specifically for typing into fields, while structural actions use discrete logits scoring. The runtime also includes page-settling waits, visibility and occlusion checks, DOM-freshness checks, read-only protection, immutable execution traces, and external URL, title, and text assertions for outcome verification. The project provides a command-line interface, a Python API, and installable agent-skill integration, using Playwright Chromium for browser execution. It supports offline model operation after local weights are downloaded and is released under the MIT License.
JevRouter is a local-first agent capability router for models, subagents, skills, MCP tools, CLIs, and DSH plugins. It presents these capabilities as one candidate set and uses Jev for typed selection while enforcing availability, permissions, risk, and confirmation policies. It is decision-only by default and does not execute selected tools implicitly. The `route` operation answers one capability-selection question; `plan` selects capabilities for multiple steps using serial, batch, or decomposed strategies, with optional beam sequence search and contextual routing. Candidates can be supplied inline or discovered from Skill directories, MCP configurations, CLI help output, and DSH manifests. The router preserves Jev probabilities and provider responses, validates supplied permissions and input schemas, filters unavailable or disallowed candidates, and can select a safe fallback while retaining the original Jev choice. The CLI, Node.js SDK, HTTP server, and MCP adapter expose the routing contract. Decisions and plans are written as append-only receipts with provenance hashes, and a local dashboard reads those files without making provider requests or uploading data. It supports the official Jev API and OpenRouter, has an offline demo provider, requires Node.js 20 or later, and is distributed under the MIT license.
Jevmind is a Python decision layer for software agents. It turns agent decisions into typed answers such as yes/no results, choices, and scores with confidence values, then applies a code-defined gate: uncertain answers escalate, trusted positive answers may act, and trusted negative answers are held. Its decisions are recorded in an append-only, hash-chained ledger, graded against later outcomes, and optionally recalibrated with Platt scaling. It includes nine skills for compacting tool output, navigating repositories, reviewing diffs, routing tasks to model tiers, checking completion claims, curating training data, walking linked markdown vaults, guarding commands, and running a structured-state control-loop demo. The default local brain uses readable rules, reflexes, and BM25 retrieval without a language model; an optional Jev HTTP brain can answer the same typed questions, while replay mode uses recorded answers. Jevmind runs as a command-line tool and MCP server, includes a Claude Code hook for shell-command screening, supports Python 3.10+, has no runtime dependencies, and is distributed under the MIT license.
A personal Codex skill and orchestration workflow for splitting software-development tasks between GPT-6 Astra and DeepSeek V4.1 Flash. Astra handles planning, architecture, high-stakes decisions, task briefs, and final review; Flash handles scoped repository discovery, implementation, testing, debugging, and routine verification, then returns a patch and evidence for Astra's acceptance pass. The workflow supports existing plans and phased implementation bundles, normally uses one writer, and includes verification, checkpointing, dry-run installation, backups, and guarded undo receipts. It is an early release requiring a Codex client with native subagents, Python 3.11 or newer, GPT-6 Astra as the root model, and an already configured Codex Router route for DeepSeek V4.1 Flash. It installs a skill, a named builder agent, and a scoped workflow policy without changing credentials, the root model, or Router configuration; no third-party Python dependencies are required.
Mr. Mak Workspace is a local Windows desktop workspace for Codex CLI and Claude Code CLI. It combines real CLI chats with a project workspace for folders, research, images, files, Markdown documents, project reports, and saved project materials. The application provides chat history and tabs, agent activity indicators, file and folder insertion, project cards, previews for media files, and a right rail for project skills, knowledge, workflows, MCP connections, settings, and help. The repository includes fourteen project skills covering areas such as planning, handoffs, image references, media generation, Three.js, Blender, video inspection, and dictation. It can also provide an optional voice coordinator using Codex CLI and an OpenAI API key; external providers and MCP connections are optional and use the user's own accounts. The Windows installer includes the local Node service but does not bundle the supported CLIs or provider accounts. The native application targets Windows x64, while browser report previews can run elsewhere. Application code and original workflow documentation are MIT-licensed, with third-party skill materials retaining their original licenses.
ThinkingOrbs is a SwiftUI package by Haplo LLC that provides dotted 3D loading indicators for AI and agent interfaces. It includes nine hand-tuned designs representing states such as searching, solving, listening, connecting, composing, and waiting; eight use rotated, depth-shaded, z-sorted 3D forms and one uses a morphing outline. The package provides regular and small sizes, status-label views with optional shimmering text, localization and accessibility labels, speed and pause controls, and public frame geometry for custom renderers. Each orb is drawn with grayscale dots in a Canvas inside a TimelineView. Timelines pause when an orb is offscreen or the app is backgrounded, while Reduce Motion displays a representative static frame. The package supports iOS 17+, macOS 14+, tvOS 17+, watchOS 10+, and visionOS 1+, and is distributed as a Swift Package under the MIT license.
Herdr GPUI is a native Rust/GPUI desktop client for a separately installed Herdr daemon. It displays the daemon's terminal sessions, split panes, workspaces, Git worktrees, and agent activity without running another terminal emulator or wrapping the TUI. The daemon owns terminal processes and session state. Herdr GPUI connects to its local or saved remote daemon through the Herdr client socket, receives binary protocol frames and surface patches, renders the terminal surfaces, and sends semantic input back; closing the GUI leaves the daemon and its sessions running. The project is distributed from the repository as a signed, notarized macOS app through Homebrew, with additional Linux packages, experimental Windows builds, Nix support, and source-build instructions. The daemon must be installed separately. It is licensed under Apache-2.0.
Paperclip is an open-source, self-hosted control plane for organizing and running teams of AI agents. Its Node.js server and React UI let users define company goals, assign agents roles and tasks, and monitor work, budgets, approvals, costs, and audit activity from a shared dashboard. Agents run through scheduled or event-based heartbeats. The system maintains organization charts, goal ancestry, task dependencies, persistent session state, isolated workspaces, scoped secrets, runtime skill injection, and atomic task checkout with budget enforcement. It supports agent adapters and runtimes including Claude Code, Codex, Cursor, Bash, HTTP/webhook agents, and plugins; recurring routines can create tracked issues and wake assigned agents. Paperclip supports multiple isolated companies in one deployment, governance and approval gates, cost hard stops, agent pause/resume/termination, company export and import with secret scrubbing, and optional OpenTelemetry and Sentry integrations. It can be installed through the Paperclip CLI or run from source; local setups use embedded PostgreSQL and file storage, while production deployments can use an external PostgreSQL database. The project is distributed under the MIT license.
GitHub Actions Runner Images is the source repository used by GitHub to create VM images for GitHub-hosted Actions runners and by Microsoft for Azure Pipelines hosted agents. It defines Linux, macOS, and Windows images for x64 and Arm64 architectures, including their YAML labels and preinstalled software. The repository contains image definitions, build sources, release information, and policies for software installation, image support, version updates, and deprecation. Images are typically updated weekly; the `-latest` labels migrate gradually to newer stable operating-system versions, while GA images support at most the two newest OS versions and beta images are used for feedback before general availability. The repository also documents package-manager-based installation, supported tool-version strategies, and instructions for building a VM image from the source.
OpenRig is an open-source, self-hosted multi-agent harness for coordinating AI coding agents such as Claude Code and Codex as one managed team. It uses a local daemon, CLI, terminal UI, MCP server, SQLite, tmux, and runtime adapters. Users define agent topologies in YAML with pods, seats, communication edges, and continuity policies, then use commands such as `rig up`, `rig send`, `rig broadcast`, `rig chatroom`, `rig down --snapshot`, and `rig discover`/`rig adopt` to launch, coordinate, inspect, snapshot, restore, or take over existing sessions. Its MCP tools let agents manage their own topology, while the TUI exposes topology, seat, project, feed, terminal, and system views. OpenRig requires Node.js and tmux; herdr, cmux, and Docker are optional for terminal workspaces and service-backed rigs. It is distributed through the `@openrig/cli` npm package and licensed under Apache 2.0.
Whiteboard is an open-source desktop app for humans and coding agents to architect software in a shared workspace. It connects to agents such as Claude Code and Codex, giving them an SDK for drawing diagrams and describing their work on an in-app canvas. Visualizations including sequence diagrams, entity-relationship diagrams, and agent-trace quotations can link directly to underlying code, while the code-review interface provides VS Code keybindings and LSP support. Whiteboard includes a semantic, AST-aware diff viewer written in Rust. It summarizes large added functions as pseudocode and can collapse or hide changes such as tests and documentation; a WebAssembly-based plugin system makes these rules customizable. Its decision-log tools let agents query and link their traces so users can inspect requirements, implementation choices, and autonomous decisions. The app runs against local checkouts, is distributed for macOS, Windows, Ubuntu, and Fedora, and is licensed under the MIT License. It is self-hostable, although hosted team functionality is planned. Current limitations include no file editing within Whiteboard and limited support for reviewing multiple repositories together.
NeoHorse is TokenRhythm's family of open-weight causal language models for text-based agent workflows, including tool use, coding, and instruction following. NeoHorse-1 uses routing-guided agentic post-training: a harness assigns tasks to a heterogeneous model pool, records tool interactions and outcomes, estimates capability demand, and feeds capability-level feedback into later training mixtures. Updated models can return to the harness in an evaluation-selection-update loop intended as a prototype for recursive self-improvement. NeoHorse-1 is released in approximately 4B and 9B parameter variants, post-trained from Qwen3.5 models, with text input and text output interfaces and deployment examples for vLLM and SGLang. The related NeoHorse-Jev-4B model uses prefill-only inference to return structured Choice, Noul, and Score decisions and probabilities for routing requests, selecting tools, or controlling workflows. The models are released under the Apache License 2.0.
Jive is an open-source terminal coding agent that plans work as executable graphs. It replaces sequential tool calls with graph calls: the planner produces a directed acyclic graph containing tool calls and Jev calls, allowing the agent to perform multi-step profiling, dataset analysis, and repetitive tasks with fast decisions inserted between harder reasoning steps. The project emphasizes a lightweight, token-efficient agent scaffold with eager execution, flexible graphs, and support for system-one and system-two models. It can be installed with the project's shell installer and is distributed under the MIT license.
cli-faq-shortcuts is an agent skill that analyzes a developer's coding-agent history and turns repeated requests into project-specific slash-command shortcuts for Claude Code, Codex, and Cursor. Its local extractor reads prompts from the relevant Claude Code, Codex, and Cursor history files, excluding subagent turns and scripted runs. The agent groups differently worded prompts by intent, counts recurring asks, checks existing shortcuts and project tools, and presents candidates for the user to select. Each selected shortcut is written as a SKILL.md file under the project’s .claude/skills directory, linked through .agents/skills so the supported agents can load it; the repository also records mappings in CLAUDE.md or AGENTS.md. Shortcuts can point to existing scripts and queries, include project-specific cautions, and use a dry run before actions that write or send data. The extractor can be run independently with Python and reads local files without making network calls. The repository supports installation on macOS, Linux, and Windows, and is licensed under Apache-2.0.
Keel is a local-first native macOS coding workspace that runs coding agents through a Rust/GPUI application. It combines sessions, a composer, transcripts, a terminal, change inspection, settings, Git history, crash recovery, and an agent graph showing active agents, subagents, and files as shared context; agents can be steered or stopped from the graph. It connects Claude Code, Codex, Cursor, Grok, Hermes, and pi through the Agent Client Protocol, and also includes an embedded DeepSeek agent loop with host-enforced tool focus. For unpinned tasks, a local Laya selector running through Core ML or an optional hosted Jev selector chooses among host-prepared routes or abstains. Keel validates each choice before applying it, falls back to the ordinary route when a choice is rejected, stale, or expired, and records candidates, validation, fallback, and observed outcome in bounded decision receipts. Decision receipts can be exported as JSONL and summarized with CLI reports. Keel also provides headless and daemon modes, while each coding provider retains its own authentication, model configuration, and tool loop. The repository supports Apple Silicon and macOS 15 or later for the packaged Laya model. It can be built from source, but the repository does not currently publish downloadable app releases; packaged builds are ad hoc signed development builds. Automatic training, public installer distribution, cloud sync, and native Codex realtime voice are not implemented or included in this build.
An agent skill for Claude that guides logo projects from discovery briefs through concept development, SVG construction, testing, refinement, and delivery of brand assets. Its workflow researches category conventions in a classified library of more than 1,400 reference SVG logos, develops 8–12 concepts, builds selected concepts in SVG, and pauses at a checkpoint for direction selection before producing a full kit. Dependency-free Python tools audit SVG structure and craft rules, generate concept and test sheets, check marks at sizes down to 16 px in one-colour and reversed treatments, compare them in contextual and competitor-shelf tests, render PNGs, create presentation boards, and export favicon, app-icon, web-manifest, lockup, and other variants. It can also produce icon sets and brand-guideline materials. The skill follows the Agent Skills format, supports Claude Code, Claude.ai, Claude Desktop, and compatible agents, requires Python 3.8+ for its tools, and is distributed under the MIT license; the reference logo files are third-party trademarks excluded from that license.
LaunchVideo is a tool that turns a website URL or prompt into a 20–40-second launch video. Opus 5.5 writes a single HTML film, while a serverless OpenComputer agent checks the scene at multiple timestamps and renders each frame in headless Chromium under a controlled virtual clock. The frames are encoded into an MP4 with ffmpeg and uploaded to Vercel Blob. The project includes a Next.js web form, OpenComputer agent configuration, API routes for job creation and status, and a CLI or one-click deployment path. URL inputs are fetched for page metadata, headings, colors, and Google Fonts before generation. Rendering runs in a fresh Amazon Linux arm64 microVM and supports deterministic HTML scenes subject to restrictions such as no video, audio, iframe, CSS transitions, random values, or external images.
YuE2 Studio is a Windows desktop application for local AI song generation. It takes a musical style and lyrics, uses YuE2 to compose a melody and chords as ABC notation, engraves the result as sheet music, and renders the composition as a full song with vocals. The score can be edited and rendered again with different sounds, while saved audio codes support exact replay and variation without recomposing. The studio also supports score-first composition, melody transcription for covers through SheetSage2, lyric-level karaoke timing, six-stem separation, audio-to-MIDI conversion, LoRA loading and training, audio processing with VST3 plugins, and an optional local or OpenRouter writing assistant. It can be controlled by AI agents through a local MCP server. It is distributed as a native Windows installer with auto-update or a portable folder and does not require Python or Node.js at runtime. Generation runs offline through the bundled yue2.cpp engine on NVIDIA, AMD, or Intel GPUs, with Vulkan support for the latter two described as experimental; CPU execution is also available. The studio is MIT-licensed, while the YuE2-3B, YuE2 VAE, and SheetSage2 models are CC BY-NC 4.0 and restrict generated songs to non-commercial use unless other terms are obtained.
Omarchy Meeting Recorder is a local meeting-recording application for Omarchy on Hyprland, built with Rust, GTK 4 and libadwaita. It captures microphone audio and the computer's output as separate tracks, then uses whisper-rs and a local Whisper model to produce a timestamped transcript with speaker labels. Recordings can also be imported from files; imported single-track audio uses NVIDIA Nemotron 3 Diarization through ONNX Runtime to distinguish speakers locally. The application provides an editable transcript, waveform playback synchronized with transcript lines, speaker renaming, chapter markers, pause and crash recovery, command-line controls, and optional bar-widget integration. Chapters can be generated by the configured Omarchy coding agent; in that case, the transcript text is sent to that agent, while recording and transcription otherwise remain on the user's computer. It stores meetings as folders containing audio, Markdown transcripts, metadata, and separate track files. The project is distributed under the MIT license and can be installed from the Omarchy package repository or built from source.
mu (μ) is a coding agent with a judgment kernel, built on pi and AionUi. A small judge handles bounded decisions around context admission, command risk and approval, task framing, memory, completion, drift, browser actions, and multi-agent coordination, while the main model performs the coding work. Each decision can be active, shadow, or off and can use Jev, the local Laya judge, or another LLM; verdicts, probabilities, and timings are recorded in a local ledger that can be inspected from the command line or desktop app. The system admits tool output chunk by chunk, archives or removes stale context, applies rule-based safety checks before judgment, and uses a shared board to route findings among non-editing sub-agents. It provides an npm-installed command-line interface and a native desktop app, supports model-provider connections and importing Claude Code or Codex conversations, and states that it is in early development with no release yet; names, settings, and formats may change.
Jevry is an open-source, MIT-licensed desktop browser agent created by Michael Swissa. It is an Electron browser that combines a language model for planning and text or visual reasoning with TypeSafe's Jev model for selecting typed actions from controls observed on the current page. Chromium executes the selected operations through guarded native input rather than generated JavaScript, arbitrary selectors, or shell commands. Its loop observes page text and compatible controls, compiles supported operation-and-target choices such as clicking, typing, scrolling, or stopping, asks Jev to choose, validates the choice against the current document and target, executes it, records an input receipt, and checks the resulting evidence before continuing. It supports browser tasks such as forms, page-grounded questions, research and citation, documentation navigation, catalogs, and selected visual or numeric games. The project is an experimental developer preview for macOS and Windows; it requires a TypeSafe Jev connection plus a text-model connection, and some capabilities—including uploads, extensions, password-manager workflows, and certain cross-origin interactions—remain unsupported or unverified.
Jevgrep is a command-line tool for coding agents that finds relevant files and source context in unfamiliar repositories from natural-language questions. It uses Jev to judge relevance across folders, files, and declarations, explores qualifying branches of the repository hierarchy, selects files through content previews, identifies useful source units and surrounding context, and returns a summary followed by file locations, reading leads, and verbatim excerpts with line references. Python and TypeScript/JavaScript support declaration parsing, while other text uses a fallback. It also includes an agent skill that teaches supported coding agents when to invoke the CLI and how to use its results. The CLI is distributed through npm as @dzhng/jevgrep, requires Node.js 22 or later on macOS or Linux, and requires authentication with a supported AI provider. Searches send eligible source content to Jev through the selected provider; local filtering excludes ignored, hidden, dependency/build, binary, and obvious credential files but is not a guarantee that sensitive data is removed. The project is MIT-licensed.
reladraw is a text language and command-line tool for creating diagrams with relative positioning. It sits between automatic layout systems such as Mermaid, Graphviz, and D2 and manually positioned editors such as draw.io: users declare nodes, relationships, labels, and relative placement without specifying absolute coordinates. The parser and layout engine resolve the declarations into a diagram, while the tool reports issues such as overlaps, crossed edges, and text overflow without requiring a rendered preview. Its TypeScript CLI converts `.reladraw` files to SVG, and the repository also provides a browser version and an optional agent skill. The project is early-stage, its syntax is subject to change, and the code is licensed under Apache-2.0.
Flux is an open-source device-integration tool that connects an Omarchy desktop to an Android phone or Mac over a local network, or through Tailscale when away from home. It transfers files, clipboard text, and links; reads phone notifications; sends SMS; controls media; synchronizes Do Not Disturb; runs desktop commands; and uses the phone as a camera or microphone. It can also mirror the phone screen, support fingerprint-based sudo approval, and expose coding-agent output on the phone. The project includes a command-line interface, background daemon, native Qt desktop window, Omarchy shell plugin, Android app, and macOS app. The desktop initiates network connections, so the default Omarchy firewall does not require an additional inbound rule. Flux for Android requires Android 10 or later, while the macOS app requires macOS 14 or later.
A free PDF guide covering the prompts and setup instructions for connecting Jev with Claude and other agentic harnesses. It is distributed through the RoboNuggets Skool community; the available evidence does not specify a maintenance or update process.
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.
DeepLearning.AI courses is an online catalog of AI education from DeepLearning.AI, covering prompting, retrieval-augmented generation, agents, generative models, LLM operations, search and retrieval, AI coding, and related subjects. The catalog is organized into short courses, broader courses, and professional certificates with beginner and intermediate levels, topic filters, and collaborator listings. Featured courses include AI Prompting for Everyone, Build with Andrew, and Agentic AI; the video notes that many courses are free and can be audited.
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.
QCon San Francisco 2026 is an in-person software engineering conference and training event for senior engineers, architects, and technical leaders, held November 16–20, 2026, in San Francisco. The conference covers applied AI and machine learning, agent orchestration, evaluation and guardrails, API design, architecture, distributed systems, platform engineering, observability and resilience, developer experience, and engineering organizations. Its program is organized into 12 curated tracks with more than 60 presentations from senior practitioners describing systems and practices used in production. Optional half- and full-day training sessions run November 19–20 and cover topics including building AI agents and selecting among agent-development SDKs.
Databox is an agentic analytics platform for agencies and teams. It connects data from tools, spreadsheets, databases, and APIs, defines governed metrics through a semantic layer, and combines dashboards, reports, goals, and KPIs with AI analysis. Its AI Analyst answers questions using live data, while agents and automations run recurring analysis and follow-up workflows; its MCP capability grounds AI tools in Databox data and business context. The platform states that data is encrypted and access-controlled and is not used to train AI models.
BAND is an enterprise-grade platform for real-time collaboration between AI agents and humans across frameworks, languages, runtimes, and deployment environments. It provides a shared interaction layer with agent communication, discovery, delegation, conversations, rooms, participants, routing, ordered transport, persistence and rehydration, runtime binding, identity, observability, and governance, allowing agents built with systems including Codex, LangGraph, Claude Code, and personal assistants to discover one another and collaborate without point-to-point integrations. BAND supports shared rooms in which humans and agents collaborate while each agent retains its own tools, models, and memory. Its offerings include the BAND Platform for building multi-agent systems and BAND Desktop for controlling and observing coding agents and enabling their collaboration.
Graphite is an AI code review platform for teams using GitHub. It supports creating, reviewing, and shipping changes within pull requests, and its evaluation set is built from developers accepting or rejecting its review suggestions. The service is presented as a way to review and deliver software in workflows that include autonomous coding agents.
Arize AI is an AI agent observability, evaluation, and improvement platform. It provides tracing, evaluation, and experimentation, using production signals to support continual improvement of agents. The platform is available through Arize AX and a terminal-based setup.
WSO2 is an open-source and SaaS software platform for API management, integration, identity, and AI governance in the agentic enterprise. Its Agentic Enterprise Fabric is designed to govern agents, connections, and costs, including securing and managing agents, APIs, AI systems, and MCP across gateways; building workflows spanning agents, people, and systems; verifying and auditing human and AI-agent identities; and providing controlled, observable paths from code commits to production. The platform also serves financial-services, healthcare, and government use cases.
DX is a developer intelligence platform designed by researchers for measuring developer experience, engineering productivity, software health, and AI-human collaboration. It gathers organizational data to identify bottlenecks, assess how developers work, and support data-driven improvements across software engineering teams. Its AI Measurement capability tracks AI-generated code by commit, pull request, team, agent, and repository to assess utilization and impact. The platform also provides AI enablement through a context layer for agents, developer-experience analysis, and engineering-productivity measurement; the associated DX AI Measurement Framework considers utilization, impact, and cost.
OpenAPPA is an open-source security tool for agentic applications. It sits between an agent and its tools, tracking the sensitivity and trust of data the agent reads and checking every outbound action against a policy before dispatch. Its APPA (Agentic Permissions Policy Algebra) engine uses declarative TOML policies and a pure decision core based on the event log, so it can run in-process from Rust or Python or as a sidecar. The project includes integrations for Claude Code and Amp, with checks applied to tool calls and results. OpenAPPA is currently a preview and RFC, and its configuration and wire interfaces may change.
Codex ChatGPT Web is an unofficial launcher that uses browser automation to make ChatGPT Web models, including available Pro models, selectable as native models inside the Codex coding agent. It preserves ChatGPT Web features such as context, images, streaming, and separate usage limits, and its Full harness mode connects ChatGPT tool calls to the current Codex task's files, terminal, tools, and approvals through MCP. A Zero Risk mode lets users paste prepared prompts and send them manually while using a separate MCP connector. The launcher bundles its browser and runtime, supports macOS, Windows, and Linux releases, and is distributed under the MIT license. It is not an OpenAI API or OpenAI-affiliated product; its browser automation depends on the ChatGPT interface and can be affected by UI changes.
Open Slide is a presentation framework built for AI coding agents. An agent describes a deck in natural language and writes React pages, while Open Slide provides a fixed 1920 × 1080 canvas, scaling, navigation, hot reload, presentation and presenter modes, and an in-browser inspector. Its agent skills support deck creation and slide authoring; the inspector records element comments as source markers that an agent can apply. The framework also manages images, video, fonts, and SVG logos, and exports decks as static HTML, PDF, or editable PPTX files. It is distributed as a pnpm/Turbo monorepo with an `@open-slide/cli` scaffolder and `@open-slide/core` runtime, and produces static builds deployable to standard static hosts. The repository is MIT-licensed.
px0 is a browser-based IDE for reviewing AI-generated code, developed by px0-ai. It provides native Git and GitHub integration for pull-request and unpushed-commit review, including scoped diffs, inline draft comments, staging, commits, and pushes. Its navigation tools include fuzzy file search, symbol outlines, workspace-wide regular-expression search, and virtual rendering for large files, while its browser interface can hand edits to local coding harnesses such as Claude Code, Gemini CLI, Cursor Agent, OpenCode, Codex, Aider, and Goose. px0 is distributed as a static Go binary with no runtime dependencies and can run locally or on a remote server, VM, or container; the project is MIT-licensed.
Coucou is an open-source desktop companion for Claude Code and other coding-agent sessions, appearing in the macOS notch or as a top-of-screen island on Windows. It displays session events such as files read, edits, and commands run; surfaces Claude Code permission requests for Allow/Deny approval; opens the relevant terminal on macOS; provides built-in Claude chat; and accepts dropped files as context. It can also attach a macOS window as Claude context and display optional integration pills for services including GitHub, Vercel, Notion, and others. On macOS, a hook script forwards Claude Code events over a Unix socket and waits for approval responses, while a borderless NSPanel and a SwiftUI Canvas render the animated Mochi character. The native Swift 6, SwiftUI, and AppKit application has no third-party dependencies. On Windows, a Tauri 2 application uses Rust, TypeScript, a transparent always-on-top window, Canvas 2D rendering, and a named pipe for hook events. The project states that it collects no telemetry, requires no account, and stores credentials in the macOS Keychain or Windows Credential Manager. Coucou is distributed from the project's releases and can also be built from source. The code is licensed under MIT; the Mochi name, character, icon, sounds, and media are separately reserved by the author. The Windows installer is temporarily unavailable according to the README because its unsigned build was flagged by Microsoft Defender.
DSCODE is a macOS terminal coding agent and CLI built on DeepSeek Harness. Its persistent shell retains the working directory, environment, background jobs, edits, searches, patches, and test runs, while the TUI, CLI, and scripts share one session runtime. Sessions can hand tasks to other sessions, run side questions in read-only child sessions, delegate work to child agents in isolated Git worktrees, and use an independent read-only model to review changes and approve permissions. The `dscode exec` command supports non-interactive scripts and CI, with output streamed to stdout and tool activity and session identifiers sent to stderr. It also supports MCP servers, triggers, cross-session memory, multiple model providers, and a workspace-write sandbox with human-approval and automatic-review modes. Distribution is available through npm, Homebrew, GitHub release tarballs, and source; the project requires macOS 14 or later and is licensed under MIT. It is an independent community project, not an official DeepSeek product.
onetake is a Claude Agent Skill for creating product launch films, teasers, and feature demos as continuous one-take animations rather than sequences of cuts. It rebuilds product interfaces from screenshots in HTML, places them on the camera plane, and uses a motion library of measured spring, entrance, carry, collision, simulation, camera, and fluid-light movements. Its workflow requires a beat sheet in which each boundary identifies what survives into the next beat, then renders deterministic frames with sampled linear-light motion blur and event-based sound. Before a film is shown to a human, probe.py records frame contents, detects beat boundaries, and uses a continuity oracle to check whether visual elements carry across them. The verification also rejects uniform shot timing, missing stillness, clipped audio, fast movement without blur, and subjects leaving the frame. The repository includes rendering, verification, probing, reference-analysis, still-image, footage, narration, and sound scripts, with draft output at 1080p30 and final output at 4K60. It requires Python with Playwright and Chromium, NumPy, SciPy, Pillow, and Matplotlib, plus FFmpeg and Node; narration additionally uses faster-whisper and Kokoro TTS. It is distributed under the PolyForm Noncommercial 1.0.0 license, which permits personal, educational, research, and other noncommercial use but not commercial use.
ReelMimic is a local 2D animation tool that uses Claude Code or Codex to create a new video from a reference video and a brief. It analyzes the reference's shot count, pacing, BPM, transitions, framing, colors, and camera movements, then produces a storyboard, character and asset plan, and style frames for approval. After approval, multiple AI agents build different parts in parallel, while separate agents review completed shots and request fixes with before-and-after screenshots. The tool supports seven drawing engines: vector/motion graphics, hand-painted watercolor, crayon picture book, pixel art, paper cut-out stop-motion, whiteboard doodle, and anime cel; new styles are defined in Markdown. It runs on the user's computer, uses the user's Claude Code or Codex account, and does not reuse the reference video's footage, characters, logos, or assets. The repository is MIT-licensed and has been tested primarily on Windows, with macOS and Linux support described as less tested.
Agent Console is an open-source, local-first observability tool by LockedIn Labs for AI coding agents. It reads Claude Code and Codex transcripts to show token usage by cache reads, cache writes, output and uncached input, model and session activity, list-price cost estimates, burn rate and dollars per hour. A self-hosted hub can combine privacy-limited usage metadata from multiple machines over TLS, while keeping prompts, replies, file paths and file contents local. It also provides optional Claude Code OpenTelemetry and Kong or LiteLLM metric ingestion, a Prometheus endpoint, Grafana dashboard, presenting mode, alerts, and policy hooks. It runs locally from source or release downloads on macOS, Linux and Windows, requires Node.js 22 or newer for the source route, and is licensed under the MIT License.
Rungic is an AgentOS product that runs alongside Android on compatible phones, providing a Linux desktop with KDE Plasma and desktop applications such as Firefox, Blender, Krita and VS Code. The Linux environment runs in an LXC container on Android's kernel rather than in a virtual machine or emulator, while an Android app connects its display, touch input, sound and camera to the phone, a floating window or a TV. Users can install software through apt, Flatpak or Discover and use the phone as a touchpad and keyboard when casting. Rungic includes a bundled assistant whose reference integration uses a realtime voice model for conversation and Codex for background tasks. The assistant plans tasks, opens applications, clicks, types and returns created files in the conversation; its work can run in a separate desktop workspace so the user can continue using the phone. The system supports multiple agent workspaces, shared project folders, desktop control, phone controls and proactive system-care suggestions that record evidence, investigation results, repair plans and user decisions. Rungic exposes these capabilities through two MCP servers, command-line tools, D-Bus services and standard Linux interfaces, allowing other agents to be adapted to it. Rungic is under active development and in private preview. Its device adaptation currently requires a compatible, unlockable Android phone with an appropriate GKI kernel, ARM64 support and a Snapdragon processor with an Adreno GPU; the repository documents tested Motorola devices and separate preparation, Linux image-building and installation stages. Device preparation or bootloader unlocking can erase user data, and the repository advises backing up the phone and checking manufacturer and application restrictions.
Tusk is a native, keyboard-driven database client for macOS, Windows, and Linux, written in Rust with the GPUI framework. It connects to databases including PostgreSQL, MySQL, SQLite, SQL Server, Oracle, ClickHouse, Snowflake, BigQuery, Redis, MongoDB, Cassandra, and DynamoDB, and provides a virtualized GPU-rendered data grid, editable tables, schema and DDL tools, SQL editing with language-server completions, query history, exports, backups, SSH tunnels, and connection imports. Its AI assistant reads the relevant table schema, writes a SQL query into a new tab, and explains its assumptions; it does not execute SQL on its own. Tusk can connect the assistant to local agents such as Claude, Codex, or Gemini CLI through the Agent Client Protocol, while its built-in MCP server gives those agents access to an open connection. The application stores credentials in the operating system's credential store and states that it has no account requirement or telemetry. Tusk is free and open source. It is distributed through signed macOS releases and Homebrew, Windows archives, and Linux packages, with source builds available through Cargo. The repository specifies macOS 14 or later on Apple Silicon, Windows 10 or 11, and Linux on a Wayland desktop, with Xwayland supported as a fallback.
hypoarena is a fully offline scientific hypothesis-discovery workbench and command-line tool. It generates deterministic synthetic literature containing planted causal chains, competing hypotheses, paraphrase clusters, distractors, and contradictions, then runs a generate–debate–evolve loop through pluggable agent adapters that propose, critique, and revise hypotheses. Its pipeline includes span-level citation and claim-grounding checks, paraphrase deduplication using hashing, n-gram Jaccard, TF-IDF, and MinHash LSH, Bradley–Terry/Elo tournaments for ranking hypotheses or agents, hypothesis evolution operators, and Bayesian evidence accumulation. It produces Markdown and self-contained HTML reports with rankings, grounding flags, deduplication clusters, belief updates, run metadata, and limitations. The core runtime depends on NumPy; an optional CPU-only PyTorch extra demonstrates a trainable ranker. Examples and tests run without network access, real model calls, or downloaded weights, and the project is licensed under the MIT License.
iCode is a lightweight, extensible, fully offline terminal development platform and toolkit for orchestrating AI agents and workflows, developed as an open-source project by openJiuwen-ai. Its terminal interface shows the active agent, model, approval mode and session; renders Markdown and diagrams; and provides workflow execution views with per-node models, tool calls and token spending. Agents are configured rather than coded and can include instructions, tools, sub-agents, skills, MCP servers and memory. Model profiles from different providers can be switched during a conversation, while file diffs, turn-based rollback, token and cache usage, model/tool timelines, and an embedded shell expose and control execution. iCode does not include models, telemetry, analytics or crash reporting; it uses only the providers, MCP servers and hooks configured by the user. The repository describes the project as a work in progress, requires uv to run, and distributes it under the Apache License 2.0 alongside separately licensed third-party components.
Agent Office is a self-hosted 3D workspace for coordinating coding agents across GitHub repositories. It creates a floor for each project, places Claude Code, Codex, OpenCode and other supported agent workers at desks, streams their terminals, and lets users assign issues, queue tasks, provide Git worktrees, inspect changes and open pull requests. Workers can also list, hire, message and dismiss other workers through the agent-office MCP server or command-line interface. The office includes shared chat, voice, screen sharing and a whiteboard, plus a 2D /lite interface for phones and slower computers. It runs locally or can be deployed to AWS, Azure, Railway, Fly.io, Dokploy or an Ubuntu/Debian server, with multi-user accounts and per-user Claude and GitHub sign-ins. The repository describes it as work in progress, subject to breaking changes, and distributes it under the MIT license.
seiso is a Markdown convention and linter for project documentation written by AI and read by people and coding agents. Its convention assigns each document a kind, such as how-to, reference, or ADR; keeps each fact in one canonical location; requires pointers to named files or symbols; separates different concerns; and avoids rapidly changing values in long-lived pages. The reference implementation checks documents against the convention and reports where each violation occurs and how to fix it, including the decision needed when a judgment call is involved. Stable rules run by default, while experimental preview rules require an explicit option; the CLI also provides commands for initialization, rule explanations, parsing, and checks. It can be installed through Cargo, PyPI, npm, or pipx, and integrates with Claude Code hooks, pre-commit, and CI. The project is licensed under MIT.