704 tools and products — trending open source, and what gets used in AI and other work.
Marketing OS is a Markdown-based agent skill that turns Claude, Codex, or Cursor into a structured marketing workspace. Its 14 modules cover website and funnel audits, AI-search citability, copy, hooks, paid ads, email, social posts, launches, positioning, pricing, competitor research, app-store optimization, analytics, and prose-quality checks. The skill routes each task to the relevant module and can fan out multidimensional work across subagents when the host supports it. It produces scored reports, prioritized fixes, diagnostic briefs, marketing copy and sequences, launch plans, and other finished artifacts rather than advice alone; its reports are designed to identify what could not be determined and label scores as heuristics. It is distributed as pure Markdown under the MIT license and can be installed through Claude Code, uploaded to Claude, or copied into the skills directory of compatible agents.
Zoetrope is a terminal and browser visualization tool for Claude Code sessions. It reads Claude Code's local JSONL transcripts and renders the main agent, spawned subagents, workflow groups, and their tool calls as a live flow graph, updating as a session runs or replaying a completed session from its recorded timestamps. Its event-indexed timeline supports scrubbing, pausing, stepping between prompt eras, following the live edge, and seeking backward to view the graph at an earlier state; agent cards show status, current tools, tool counts, and output tokens, while tool calls resolve to success or failure. The browser version uses the same engine compiled to WebAssembly, and the README states that sessions remain local and read-only. It is distributed through Homebrew, Cargo, prebuilt binaries, source builds, and the browser interface; its command-line executable is `zoe`.
Autoprompt is a coding-agent skill and CLI that turns a development goal into a managed loop of scoping, implementation, testing, review, repair, and verification. It coordinates coding agents with configurable concurrency and model routing, and supports installation into several coding-agent environments, including Claude Code, Codex, OpenCode, Kilo Code, and VS Code. The repository reports an OpenCode comparison in which Autoprompt reduced failures from 29 of 89 tasks to 16, or 45% fewer failures, with an expected trade-off of roughly three times the execution time and twice the token use. It requires Node.js 20+, Python 3.11+ with PyYAML, and Bash 4.3+ on macOS or Linux.
Jixu is a TypeScript harness for running a single AI agent in durable, recoverable Threads. An immutable Agent definition is given Tools and Skills, while each Thread records execution, context decisions, and external work as ordered Events; state is deterministically derived from those Events, with external work recorded before dispatch. This allows a Thread to recover after interruption, replay completed work without repeating live side effects, fork, or continue later without a second workflow engine. The public API centers on `createHarness`, `createThread`, and `thread.send`; the project also provides a native terminal UI and SQLite-backed storage packages. Jixu is pre-1.0, and its public API may change before 1.0.
nopus is a deterministic prose checker for coding-agent responses. It evaluates completed answers for uncommon or highly uncommon wording, abstract vocabulary and sentences, noun and modifier stacks, dense phrase load, and formulaic filler, using packaged language-frequency data, human-rated word-concreteness data, a computing glossary, and a small allowlist of literal style cues. When a response exceeds the configured complexity threshold, it requests one clearer rewrite; rejected responses can be hidden from the terminal transcript while remaining in the session and model history. It is distributed as an extension or plugin for Pi, Claude Code, and Codex, with controls for checking, sensitivity, activation, and hiding the original response.
Benjamin-Plus is an instruction-set skill for coding agents that aims to reduce token and tool-call usage without changing the agent's implementation task. It teaches five operating habits: batch repository reconnaissance into one pass, inspect narrow file windows unless full data is needed, probe dependencies in one command, treat the task's specified verification command as the definition of done, and poll unfinished builds at longer intervals rather than repeatedly checking them. The skill is intended to be injected into an agent's instructions rather than installed as a discoverable skill. Its repository provides an injected instruction file for Claude Code hooks, Codex CLI's AGENTS.md, project CLAUDE.md files, or other agents' system prompts. The project reports measured cost reductions ranging from about 10% to 18% depending on baseline behavior, with unchanged quality in its reported evaluation; it also documents a cross-platform Java SWE-bench measurement with reduced cost and tool calls.
Fullstack-agent is a Claude Code installer wizard that assembles a local AI-agent setup from several optional components. It can install ai-memory-vault for persistent memory stored in plain-text files, backtalk for push-to-talk voice input and spoken replies, ai-visualizer for full-screen visual states synchronized with the conversation, and barehands for optional webcam hand tracking that moves notes and images on screen. The wizard presents the components in a guided conversation and installs only the pieces selected by the user. It runs on Claude Code and requires a Claude subscription; macOS and Linux also use git, while the Windows setup downloads the repository as a ZIP and configures git during installation.
Procoder is a Go binary that provides commit gates and quality controls for AI coding agents. It checks formatting, tests, linting, secrets, Git and repository hygiene, CI and infrastructure hygiene, and documentation health, while treating unavailable checks as failures. Its tools can be run by the agent, and lifecycle hooks can invoke checks at fixed points; the binary computes and reports findings while the agent reviews and applies changes rather than modifying repository files itself. A lessons loop records escaped bug classes for future checks, and adapters support Claude Code and other agents that use integrations such as AGENTS.md. It has no runtime dependencies and is distributed as a single binary.
Hermes3D is an open-source, self-hosted visualization and interaction layer for AI agents. It presents connected agents as workers in a live retro 3D office, with surfaces for standups, pull-request reviews, task execution, monitoring, and agent chat; it also provides a 2D pixel-office view for lower-power machines and an office builder for editing layouts. The frontend connects to agent runtimes through a bundled Hermes WebSocket gateway adapter, a direct HTTP custom runtime provider, or a built-in demo gateway. Runtime state remains in the connected backend, while Studio stores local interface preferences. Hermes3D does not build or run the upstream agent runtimes; it supplies the office UI, Studio, and adapter/proxy layer using the Hermes3D gateway protocol. The repository describes it as an independent community project maintained by LukeTheDev and unaffiliated with the backend teams it connects to.
Alvarmethod is a portable collection of agent skills that implements Eero Alvar’s AI learning loop for Codex, Claude Code, Grok, Pi, OpenCode, Cursor, and other skills-CLI agents. Its full `teach` skill probes the learner with graded questions, builds a Mermaid dependency DAG, teaches one reasoning step at a time, and uses a native quiz tool to lock in each node; a failed quiz inserts a prerequisite before continuing rather than merely repeating the same material. The pack also includes separate skills for probing, maintaining a learner profile, generating a visual, and fact-checking claims before they are taught. It stores learner, map, session, and visual files in a `.alvar/` directory and can be installed globally or per project through the `skills` CLI or its installer. The repository states that the skills, installer, and documentation are released under the MIT license.
Habit Hooks is a developer tool that steers AI coding agents toward code-quality and refactoring practices. It runs project linters and replaces each raw rule violation with a short coaching guide that explains an actionable fix, using the linter finding as a cue and the guide as the response rather than presenting the agent with a bare metric. The project is designed to reduce metric gaming, technical debt, and the context needed for later tasks; its repository reports an independent study in which coaching produced genuine fixes more often than bare linter targets. It is installed as a Python package with `uv`, pip, pipx, or Homebrew, then initialized in a project with `habit-hooks init`. Initialization detects the project language and writes `.habit-hooks/config.toml`; separate plugins are provided for Python, TypeScript, PHP, and Java, with language-specific detectors such as Ruff, ESLint, and jscpd enabled separately.
Vertex AI is Google Cloud’s managed platform for developing and deploying machine-learning and generative-AI applications. It provides hosted models and APIs that applications, including agents, can call at runtime, along with tools for model training, evaluation, and serving.
Cloud Logging is Google Cloud's managed logging and observability service. It collects application and infrastructure logs, including agent prints and warnings, and makes them available in Logs Explorer for testing, debugging, search, and analysis.
Google Distributed Cloud is Google's on-premises and distributed cloud platform for running compute, networking, storage, and related infrastructure at a customer's site. It supports deploying trained AI models, Gemini, and AI agents while keeping data within the customer's environment.
Gemini Enterprise Agent Platform, formerly Vertex AI, is a Google Cloud platform for developers to build, run, scale, govern, and optimize autonomous AI agents and agent workflows. It provides session and memory management, persistence, parallel execution, model swapping, and built-in support capabilities.
Google Cloud Agent Observability provides visibility into AI agents’ execution paths, actions, and reasoning, with evaluation capabilities for measures such as accuracy and hallucination detection. It is documented as part of Google Cloud Observability.
NautilusTrader is an open-source, Rust-native engine and platform for multi-asset, multi-venue algorithmic trading. Its deterministic, event-driven architecture spans research, simulation, backtesting, and live execution, using Python as the control plane for strategy logic, configuration, and orchestration while also supporting systems written entirely in Rust. The same execution semantics and deterministic time model are used in research and live systems, allowing strategies to move from research to production without code changes. Modular adapters connect venues through REST APIs or WebSocket feeds; the engine supports historical quote, trade, bar, order-book, and custom data, multi-venue strategies, advanced order types, optional Redis-backed state persistence, and training AI trading agents with reinforcement-learning or evolutionary-strategy methods. It runs on Linux, macOS, and Windows and can be deployed with Docker.
terminal-browser is a command-line browser that renders Chromium inside a terminal window. It uses terminal graphics protocols such as Kitty to display Chromium's GPU-rendered pixels, captures mouse, keyboard, and operating-system input, and sends synthetic events back to Chromium. Its outer interface is built with a Rust graphics engine and a custom React renderer, with the browser content and interface drawn on a shared canvas. The CLI launches and opens URLs, supports split-pane display, lists open browser instances, and provides an agent-browser-compatible action interface for coding-agent control. It can route network requests through a remote server over SSH, allowing previews of sites running on remote machines. The project provides installation instructions for macOS and Linux and lists support for terminals including Ghostty, Kitty, cmux, and VS Code.
Kiro is a proprietary agentic integrated development environment and command-line interface from Amazon Web Services. It supports specification-driven development, steering files, hooks, and cloud deployment, and uses Anthropic models through Amazon Bedrock.
itai is Viktor's AI toolkit for Kubernetes remediation. A controller watches and classifies Kubernetes events, sends repeated warnings to an agent for analysis, and can notify an operator, create a pull request, or apply a fix.
A two-day, hands-on AI workshop from Outskill covering AI tools, agent building, workflow automation, and image and video generation. The program is advertised as including more than 16 hours of instruction with expert mentors and access to more than 10 AI tools.
DevAssure is an AI-powered software testing platform whose O2 agent reads code changes, maps potentially affected application flows, and validates them automatically, including through browser interactions based on plain-English expected behavior. It generates scriptless, self-healing acceptance tests and reports results for pull requests.
Outskill is an AI education provider that runs two-day mastermind workshops covering hands-on use of AI tools, AI agent building, workflow automation, image and video generation, and AI-assisted coding.
SPIRE (the SPIFFE Runtime Environment) is an open-source toolchain and implementation of the SPIFFE workload-identity framework, maintained by the SPIFFE community and hosted as a graduated Cloud Native Computing Foundation project. It exposes the SPIFFE Workload API to attest running software, assign SPIFFE IDs, and issue SPIFFE Verifiable Identity Documents (SVIDs), allowing workloads to establish trust through mTLS or JWT signing and verification and to authenticate securely to services such as secret stores, databases, and cloud providers. SPIRE distributes SPIRE Server and SPIRE Agent binaries, with container images also available for those components and its OIDC discovery provider. Its extensible plugin framework supports different hosting environments and integrations, including an Envoy Secret Discovery Service implementation for installing and rotating TLS certificates and trust bundles. The project provides quickstarts for Kubernetes, Linux, and macOS, along with Go and Java client libraries and example repositories.
Arcade is a runtime for the Model Context Protocol (MCP) that helps AI agents take actions in real systems. It provides authentication and permissions management, reliable tool calls, and audit trails.
Open Policy Agent (OPA) is an open-source, general-purpose policy engine and graduated Cloud Native Computing Foundation project. It uses the declarative Rego language to define rules and evaluates supplied policies and data in response to queries, returning decisions such as whether an API request is allowed, what cluster a workload may target, or which resource tags are required. Services can integrate with OPA through its Go SDK, Go API, REST API, or other documented integrations; OPA is also available as a CLI, container image, and binary. The videos specifically describe its use for Kubernetes admission policies and command-line validation before resources reach a cluster.
Kata Containers is an open-source container runtime and project that runs workloads inside lightweight virtual machines, combining a container-like interface with the workload isolation and security properties of virtual machines. Its core runtime integrates with container managers through a containerd shim v2 implementation; an agent inside each virtual machine or pod sets up the container environment, while a hypervisor provides the virtualized boundary. The project supports multiple virtualization technologies and architectures, uses a configuration file covering the runtime, agent, and hypervisor, and includes a host-capability check through the `kata-runtime check` command. The code is licensed under Apache 2.0.
Muse Code is an AI-powered terminal coding agent for inspecting repositories, investigating code issues, generating HTML reports, modifying code, spawning parallel sub-agents, and auditing pull requests.
An evaluation toolkit for Strands AI agents that measures off-script behavior, violations of behavioral guardrails, and other incorrect behavior against test and live data. It is associated with Strands Agents, an open-source AI agent SDK for Python and TypeScript.
Vois is a local AI voice-generation and audio-processing studio for writing, casting, voice selection and cloning, multi-speaker scripts, editing, and mastering. It provides local text-to-speech, more than 100 natural voices, audio tools for podcasts, audiobooks, and video, and integrations with AI agents; its Pro plan adds Omni, more than 600 languages, and Voice Design.
Vapi is a developer platform for building, testing, and deploying conversational voice AI agents. It provides a cascaded voice-agent architecture and supports customer-supplied text-to-speech servers for specialized applications.
Pipecat is an open-source Python framework maintained by Daily and the community for building real-time voice and multimodal conversational agents. It orchestrates audio and video, transports such as WebSockets and WebRTC, speech recognition and text-to-speech services, speech preprocessing, turn detection, model calls, tool calls, and streamed audio through composable conversation pipelines. Pipelines can operate as single agents or as multi-agent systems whose specialists hand off, fan out in parallel, or coordinate over a shared bus locally or across processes and machines. The project also provides a CLI for scaffolding, monitoring, and deploying agents, along with client SDKs and related tools for structured conversations and pipeline debugging.
Smallest AI is a voice-AI platform offering text-to-speech, speech-to-text, speech-to-speech, and orchestrated voice-agent models for real-time deployments.
Deepgram is a speech AI platform providing Speech-to-Text, Text-to-Speech, and Voice Agent APIs. Its services support real-time transcription and voice applications, including the speech transcription component in deployment architectures.
Gradient is a framework for training research agents with reinforcement learning. It exposes the agents’ searches, citations, tool calls, and evaluation results.
Ambient Context is a macOS menu bar app that records the text of the focused window for use by an LLM or other agent. Through the macOS accessibility tree, it reads window text every few seconds and appends deduplicated blocks to one plain Markdown file per day, including the document path or URL and an AGENTS.md file describing the format. It does not use screenshots or video and, in the current build, makes no network calls, accounts, servers, telemetry, or bundled model; password fields, password-manager and private-browsing windows are excluded, and credentials, API keys, and card-shaped numbers are scrubbed before writing. The project is early and unsigned, requires macOS 14 or later on Apple Silicon, and currently must be built from source with Node, Rust, and Xcode Command Line Tools.
System Atlas is an agent skill from Inkboard that turns architecture discussions into an explorable isometric atlas. A single data file serves as the source for an interactive map and a generated SYSTEM.md text view, keeping structures, execution flows, design decisions, and open questions synchronized. The map supports hoverable structures, pinned views, drill-down into execution steps, pan and zoom, progressive-disclosure chapters, and inspectable data packets showing routes and representative JSON payloads. The generated SYSTEM.md includes a decisions table with ADR links, structure descriptions and steps, flow tables, and an index of questions tracked by stable IDs and states such as open, resolved, or routed. The skill can be installed with `npx skills add inkboard/system-atlas`. It generates a self-contained HTML map with no build step or runtime dependencies.
kern is a fast, rootless OCI container runtime, sandbox, and virtual resource runtime distributed as a small static binary without a daemon. It creates kernel-enforced containers from OCI images, using user, PID, mount, network, UTS, and IPC namespaces, overlay or read-only roots, a deny-by-default seccomp allowlist, and cgroup v2 limits; the `--security-profile untrusted` option applies the documented hardened bundle. It can also attach named CPU, memory, disk, and device profiles from `kern.toml` to containers, or apply resource caps directly to host processes with optional Landlock write confinement. The project supports container operations, Dockerfile builds, image pull/push and save/load, stack execution through its own or Docker Compose format, and includes Python and Node SDKs plus an MCP server for agents. Its Rust dependency tree uses libc, while image pulling delegates to system `curl` and `tar`; it runs natively on Linux, requires WSL2 on Windows, and needs a Linux virtual machine on macOS.
agenttrail is a local, open-source observability layer for AI coding agents. It watches plans, tool calls, file changes, and progress from Claude Code, OpenAI Codex, Cursor, or other agents that edit files, then presents them as a live project map with repository components, dependency arrows, progress, and working, blocked, or completed states. It compares declared agent intent with observed filesystem activity, including renewed changes to supposedly finished work, and displays the current run, task list, streaming tool activity, elapsed time, recent calls, session plans, and a live repository tree. The tool runs locally through commands such as `npx agenttrail`, with no account, global installation, or telemetry. `npx agenttrail init` adds the agenttrail convention to CLAUDE.md and AGENTS.md, creates a starter PLAN.md, and installs additive local Claude Code hooks; the resulting plan and file activity are used to generate a map of roughly 5–9 repository components with dependencies and verifiable statuses. It supports one daemon per repository, a shared board tab switcher, restart via `npx agenttrail up`, and login autostart through `npx agenttrail autostart`.
backpass is a local-first command-line tool that analyzes coding-agent session transcripts and proposes evidence-backed edits to an agent memory file such as AGENTS.md or CLAUDE.md, plus project skills. It treats the memory file as weights, agent sessions as forward passes, and their on-disk transcripts as a loss signal, then collects sessions for the current repository, distills failures, aggregates repeated instruction changes, and produces diffs and skill extractions. The tool reads transcript stores from seven agent harnesses directly from disk, requires evidence from at least two independent sessions for a new instruction, and limits each run to at most five edits. Proposed changes include verbatim session quotes; analysis never writes files, while `backpass apply` presents each edit for human acceptance or rejection before applying it. It is distributed through npm or npx, requires Node.js 22.5 or later and `acpx`, uses no API keys of its own, and sends no transcripts to a separate service; obvious secrets are redacted before model calls through an already authenticated harness.
Sentio is an email inbox API and multi-tenant mail server for AI agents, developed by Truespar. It gives each agent a real email address, authenticates and scans inbound SMTP mail, scores and routes it, then delivers the message as a structured webhook; agents send threaded replies through a REST API, which signs outbound mail with DKIM, queues it, and delivers it over SMTP. Tenant isolation covers domains, mailboxes, API keys, rate limits, suppression lists, sending reputation, and spam profiles. The Rust service implements inbound and outbound mail infrastructure including DKIM, SPF, DMARC, ARC, MTA-STS, DANE, and three-tier anti-spam, and includes an MCP server for exposing email as native agent tools. The repository provides Docker deployment with PostgreSQL, Redis, NATS/JetStream, MinIO, ClamAV, and rspamd, plus an API reference and testing UI.
OwnMem is a repository-owned memory system for AI coding agents. It stores project knowledge as reviewable Markdown in a .ownmem/ directory, shared through Git so it can be cloned, reviewed, and rolled back across Claude Code, Codex, Cursor, Gemini CLI, Grok CLI, and other hosts. Its local recall pipeline compiles schema, graph, lifecycle, and evidence checks into an immutable, content-addressed snapshot. Five deterministic candidate lanes—exact matching, BM25F, n-gram, fuzzy, and graph retrieval—are fused locally; embeddings are optional and remain disabled by default until local evaluation supports them. Four delivery gates assess relevance, epistemic validity, task applicability, and action risk, allowing normal delivery, advisory output, quarantine, or abstention. OwnMem separates repository memory from trust receipts and uses quotas, duplicate gates, lifecycle rules, audits, and reversible changes to bound unattended evolution. Its rules allow automation to promote only replay-proven, quota-bounded R0 retrieval metadata, while prose, policy, and higher-risk changes become review material. The repository describes the project as local, deterministic, git-native, evidence-governed, and licensed under Apache-2.0.
MonoCode is a desktop GUI for running coding-agent command-line interfaces in tabbed sessions. Each tab represents a session, and a shared composer provides the prompt input while the selected CLI uses the user's own logged-in subscription; MonoCode does not sell tokens or act as a model provider. It supports Claude Code, Codex, Cursor CLI, OpenCode, Pi, omp, and fx when they are installed and authenticated. The application supports macOS and Linux, with an Apple Silicon macOS disk-image distribution and source builds requiring Node.js 20 or later and a current stable Rust toolchain. It is licensed under the MIT License and is described by its repository as an early project that may contain bugs.
AI Engineering Lab is a free, self-paced 24-week AI engineering course developed by Zorost Intelligence AI Lab. It takes learners from Python and machine learning through deep learning, LLM internals, prompt and context engineering, retrieval-augmented generation with vector search, quantization, LoRA and DPO fine-tuning, evaluation harnesses, coding-agent harnesses, AI agents, MCP, and cloud and Databricks platforms including Azure AI Foundry, Google Vertex AI, AWS Bedrock, and Databricks. The curriculum uses one continuous fictional freight-company case study. Each week pairs a concept with a runnable Python, SQL, or PySpark artifact; from Week 3 onward, the work includes a metric and an error note. The repository contains 43 runnable notebooks, publishes the full curriculum online, requires no signup or paid API key, and states that the first eight weeks require no GPU. It is MIT licensed.
open-sheet is a spreadsheet framework for coding agents that represents workbook models as React and TypeScript source. Instead of writing fragile A1-style cell addresses, models can use named references such as `ref('pl').column('revenue')`, which open-sheet resolves at compile time while handling cell addressing, formula references, recalculation, and formula-tree previews. It exports live formulas to XLSX, as well as CSV, HTML, and PDF formats, and reports cells it cannot compute as `#NOT_EVALUATED` rather than emitting a plausible number. The project provides an `npx @open-sheet/cli` initializer, is distributed under the MIT license, and is hosted at open-sheet.dev.
Halofy is an open-source governance layer between organizational knowledge and AI agents. It resolves actor identity, roles, namespaces, and source scope on the server; enforces access policies; and records provenance, supersedence, append-only audit history, policy decisions, and signed erasure certificates for reads and writes. The repository exposes governed memory and context operations over MCP and HTTP, including writing, reading, searching, assembling, faulting, statistics, forgetting, policy, sharing, pinning, export, and manifest operations. Postgres with pgvector is the operational authority, while retrieval engines connect through an ACL-scoped read-only driver interface; encrypted, Git-versioned knowledge provides a cold tier, and embedded PGlite is the zero-setup local default. It includes connectors for filesystem, Postgres, Obsidian, and manual CSV import, plus an offline demo and hermetic test lane using deterministic stub components.
Kubernetes-sigs Agent Sandbox creates isolated, disposable environments for running untrusted or agent-generated code. It is intended to separate such code execution from other workloads.
Data Agent Kit is an editor extension for working with data operations. It supports viewing data jobs, executing saved queries, monitoring data-flow and Spark jobs, running notebooks, and accessing data services.
Gemini Live API is a Google Gemini API for building voice agents that listen and respond through live audio-to-audio interactions. It supports real-time responses, interruption handling, audio streaming, and calls to application tools.
live-dj is an open-source voice-agent demo in which users talk to Mira, a late-night radio DJ, ask her to play music, and interrupt her while she speaks. It uses the Gemini Live API through the raw `google-genai` SDK rather than an agent framework. The browser handles microphone capture, 16 kHz audio input, 24 kHz playback, client-side barge-in, and music ducking. The server maintains one asynchronous Live API session per browser and runs the core loop of opening a session, sending microphone audio, receiving streamed voice responses, and playing them. The full application adds Mira's persona, transcripts, music-tool dispatch, and controls for playing playlists or tracks, skipping, and pausing; the tools return immediately so the voice response does not stall. A minimal backend exposes the 39-line voice-only primitive, while the full server demonstrates the complete DJ application. The repository also documents a per-turn `session.receive()` behavior that requires an outer loop for continuing conversation, and shows that microphone audio must be sent through `send_realtime_input` rather than `send_client_content`. It runs locally with `uv`, Uvicorn, and a Gemini Developer API key. The repository includes a browser client, four dream-pop tracks, persona assets, and examples of the relevant implementation pitfalls.
Free Claude Code is an independent open-source local proxy for routing Claude Code, Codex, Pi, OpenCode, and other coding-agent requests to selected free, paid, subscription, or local model providers while preserving their existing APIs. It provides a searchable model catalog and an Admin UI for configuring providers, supports automatic fallback to another configured model after provider retries are exhausted, and can be launched from a terminal, desktop app, IDE, Discord, Telegram, or phone. Optional RTK filtering reduces common terminal-output tokens, while voice input can use local Whisper or NVIDIA NIM transcription. The project states that it is not affiliated with or endorsed by Anthropic, and that provider free-tier availability and limits may change.
Agent Plugins for AWS is an AWS Labs collection of plugins for AI coding agents, helping them architect, deploy, and operate on AWS. Supported agents include Claude Code, Codex, and Cursor. Each plugin can package agent skills—structured workflows and best-practice playbooks—alongside MCP servers that provide access to live documentation, pricing data, and other APIs; hooks that validate changes or trigger workflows; and references containing documentation and configuration defaults. The repository describes the plugins as reusable, versioned capabilities intended to reduce prompt context and standardize agent behavior. It warns that generative AI can make mistakes and recommends reviewing generated code, costs, security, and credentials. The repository also identifies Agent Toolkit for AWS as the successor for production use, while stating that this project continues to work and accept contributions.
Droids are Factory’s autonomous software-development agents, designed to carry out engineering work for enterprise teams. They are an AI software-development product rather than a general-purpose category.
OpenHuman is a local-first personal AI system from tinyhumansai that combines persistent memory, agent orchestration, and research tools. It stores a user's data as scored Markdown trees in SQLite on the local machine and mirrors the result to an editable Obsidian vault; its TokenJuice component compresses tool output before it reaches the language model. Its orchestration layer runs checkpointed, durable agent workflows and worker fleets on graphs, with triggers, approvals, steering, halting, and replay support. The system also provides web search, scraping, coding tools, a browser, native voice through in-process Whisper, model routing, messaging integrations, and support for provider keys or fully local Ollama models. The repository describes it as an early beta under active development.
Awesome Agent Skills is an open-source curated collection of more than 1,000 agent skills from official development teams and the community. Each listing provides a description and source link; the collection includes skills from projects such as Anthropic, Google Labs, Vercel, Stripe, Cloudflare, and others. The skills are documented for use with multiple coding-agent environments, including Claude Code, Codex, Gemini CLI, Cursor, GitHub Copilot, OpenCode, and Windsurf.
vgpu is an open-source TypeScript library for WebGPU, developed by Vercel Labs, covering typed shaders, 3D scenes, GPU tensors, neural networks, and mathematical visualization. WGSL files can import and export declarations like TypeScript modules; reflection tracks binding names, types, and layouts so shader bindings do not require handwritten declarations. Its tiny GPU-first API uses a single context returned by init(), which is passed explicitly to rendering entry points. The same API runs in browsers, headless Node through a Dawn-backed device, and a deterministic software mock for tests and continuous integration. Explicit frame passes handle targets, effects, clears, and draws without hidden scene-graph state. The package includes a CLI for documentation, examples, and shader validation, and the video describes an MCP endpoint for agent access.
Markdown-based agent skill that rewrites AI-sounding text to read human-written without changing what it says — works with any agent that supports skills. Rewrites against the 35 patterns from Wikipedia's 'Signs of AI writing' (WikiProject AI Cleanup): a first pass free to restructure, then a check of the draft against those patterns and the original claims before rewriting what still sounds artificial. Its rules bar invented facts — names, numbers, dates and quotes must come from the source or the writer — and preserve a writer's personal style (or follow a provided sample). The skill shows its work: the first rewrite and a critique of what still sounds artificial precede the final version.
TURNR is an AI marketing agent for home service businesses. It learns from customer calls, the business website, and existing content, then creates social media posts, video hooks, SEO blog posts, and ad copy, with a weekly email summarizing the generated materials.
MemoraX Code is a memory plugin and shared memory layer for AI coding agents, developed by MemoraX. It integrates with Codex, Claude Code, CodeBuddy/WorkBuddy, DeepSeek Harness, and OpenCode to retrieve relevant context for new tasks and capture reusable knowledge from completed work. Its memory is divided into Coding Memory for engineering lessons and design decisions, Repo Memory for repository structure and history evidence, Personal Memory for user preferences, and Procedure Memory for reusable steps and validation gates. Background writeback extracts selected knowledge from trusted workspace turns, while the bundled skill and CLI support explicit search and memory operations; repository and personal/procedure content are maintained under the documented local storage boundaries. The package is distributed through npm and requires Node.js 20 or later, with Python 3 required for Repo Memory operations. Cloud-backed search and storage require a MemoraX account, while guest mode is available for a limited period. Local trace capture is enabled by default for supported clients and may retain prompts, responses, recalled memory, reminder text, and local paths; the project documents settings for metadata-only capture or disabling traces. The repository is licensed under the MIT License.
sepia is a portable Agent Skill for Claude Code, Codex, Grok Build, and Antigravity that revises AI-assisted fiction and professional prose at the narrative-architecture and discourse levels, rather than only changing word choice. For fiction, its three-pass protocol addresses narrative architecture, discourse flow, and surface style; its rules cover issues such as overly tidy causality, explained themes, linear time, sparse character networks, uniform emotional rendering, templated paragraph flow, and predictable endings. Professional-writing rules are matched to document venues including release notes, pull-request and issue replies, postmortems, tickets, and technical articles. The package provides write, review, refactor, and recreate operations, plus a general router. Review diagnoses without editing, refactor makes minimal in-place changes, and recreate rewrites from source facts and intent. It includes a 30-feature diagnosis rubric, model-specific fingerprint corrections, shared professional-prose checks, and research references. The repository distributes the skill as a plugin package with native installation paths for the supported tools and an alternative Skills CLI installation. It is licensed under the MIT License.