AI Agent Tools

openclaw389.9k★

OpenClaw is a self-hosted AI assistant that connects to every chat platform you already use. WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Teams, Matrix, and about 15 more. One local gateway, one brain, every inbox. The setup is real work but the payoff is real too. You run a Node.js daemon on your machine (or a small VPS with Tailscale for always-on). Each messaging channel has its own auth dance: WhatsApp needs phone pairing, Telegram needs a bot token, Slack needs an app. Once wired up, you get voice wake words, browser automation, cron jobs, webhooks, and a skills platform that keeps growing. Solo users: run it on your laptop and bring your own API keys. Power users: put it on a $5 VPS and you have a private AI butler across every platform. There is no paid tier, no cloud service, no data leaving your machine. The catch: "free" still costs money. You need LLM API keys (OpenAI, Anthropic, or local models), and the WhatsApp integration uses an unofficial library that Meta could break tomorrow.

goose54.6k★

Goose is a local AI agent with full access to your development environment: it writes code, runs commands, and drives your tools using whatever LLM you point it at. Block (the company behind Square and Cash App) built it, then donated it to the Linux Foundation's Agentic AI Foundation, which makes it one of the few coding agents with vendor-neutral governance instead of a single company's roadmap. Apache 2.0, free. Extensibility is the differentiator. Goose extends through MCP servers, so the same connectors that work with other agents plug in here: Kubernetes, AWS, CI pipelines, whatever your workflow touches. It runs as a CLI or desktop app, and releases land steadily, mostly provider integrations and protocol work, plus a patched command-execution advisory in its review feature earlier this summer. Use it if you want an open, vendor-neutral agent you can point at any model, including local ones through Ollama. Quality tracks the model: with a frontier model it's impressive, with small local models it struggles on complex tasks. The catch: giving an agent full terminal access is powerful and risky, so review what it runs, especially destructive commands. And model API costs are the real price. Expect $30-100/mo for daily use unless you go local.

LibreChat44.8k★

LibreChat is a self-hosted AI chat interface that connects to multiple LLM providers (OpenAI, Anthropic, Google, local models) through a single unified UI. Self-host it and your team gets a unified chat UI that works with whatever models you're paying for (or running locally). No vendor lock-in. MIT license. Multi-model conversations (start with GPT-4, switch to Claude mid-chat), file uploads, code interpreter, plugins, conversation search, and user management are all built in. Docker Compose setup gets you running in minutes. Fully free to self-host. No paid tier, no gated features. You bring your own API keys. Running it locally with Ollama means zero API costs. Self-hosting ops: moderate. Docker Compose handles most of it, but you need MongoDB for the backend. Updates are frequent (active development), which means staying current takes attention. Figure 2-3 hours/month. Solo: self-host, connect your API keys, done. Small teams: add user accounts, share a single deployment. Growing teams: works well but you'll want to think about rate limiting per user. Large orgs: evaluate security hardening. It's not built for enterprise compliance out of the box. The catch: the feature velocity is both a strength and a risk. Breaking changes happen. And while it supports many providers, the quality of each integration varies. OpenAI is rock-solid, others can lag behind.

browser-harness18.1k★

Browser Harness gives LLMs raw access to Chrome through a single WebSocket connection. No abstraction layer, no pre-built recipes, just direct CDP (Chrome DevTools Protocol) control. When the agent encounters something it cannot do, it writes new helper functions mid-task. Self-healing browser automation. The entire codebase is under 600 lines of Python. Connect to Chrome with remote debugging enabled, and your agent can navigate, click, fill forms, extract data, and extend its own capabilities on the fly. From the same team that built the browser-use framework, this is the stripped-down version for agents that need complete freedom. Developers building AI agents that interact with websites: this is the thinnest possible layer between your LLM and a real browser. The free tier at cloud.browser-use.com gives you 3 concurrent remote browsers for testing without managing Chrome instances. The catch: "complete freedom" means no guardrails. Your agent can navigate anywhere, click anything, submit forms. You need your own safety layer if you are pointing this at production accounts.

corsair11.9k★

Corsair is the layer that stops your agent from holding API keys. You connect it once to Gmail, Slack, Notion, Stripe, Linear, GitHub, and the rest, and the agent gets typed tool calls instead of credentials. When it tries something destructive, Corsair intercepts and generates an approval link showing exactly what is about to happen. Apache 2.0, and the full SDK self-hosts for nothing. The permission model is per-integration rather than global, which is the right shape. GitHub can sit in strict mode while Slack runs open, and individual endpoints override the mode. It also does multi-tenancy properly: flip a flag and every tenant gets isolated credentials, storage, and permission handling, which is the part teams normally build badly themselves. Self-hosting is free with no per-seat charge and no cap. The hosted Hub has a $0 Hobby tier at 50 connections and 100k webhook events, then jumps to $200/mo Pro for unlimited. That is a wide gap, so model your connection count before committing. The catch is maturity. The repo is young, the integration catalog is community-extended, and an approval gate is only as good as its coverage. Audit which of your integrations actually classify a destructive action correctly before trusting it with production credentials.

cli-printing-press4.7k★

cli-printing-press is a tool that generates other tools. You point it at an API, and it builds a custom command-line interface for that API, optimized for AI agents to use. The generated CLIs have local SQLite caching, fast text search, compound query commands, and structured exit codes, designed so an agent gets predictable, parseable output instead of guessing at JSON shapes. MIT licensed, fully free, written in Go. The generator runs as a standalone Go binary. Install with go install or grab a release. To actually use it, you need a Claude Code subscription because the generation runs inside Anthropic's CLI. Generated binaries are standalone with no runtime or Docker, just a local store at ~/printing-press/. Distinctive positioning here. OpenAPI Generator and Speakeasy generate API clients, but they do not tune for agent workflows. If you are building agent toolchains and want every API connector to behave consistently for an LLM caller, this is worth trying. Otherwise, the existing client generators are fine. The catch: solo project, depends heavily on Claude Code working a specific way. If Anthropic changes their tool-use protocol or pricing structure, this gets stranded.

FrontierAgent4.6k★

FrontierAgent is Apodex's agent runtime, open-sourced alongside their model, and it aims at long-horizon file-based work rather than chat. The terminal UI ships two workflows. ReAct runs one stateful agent that researches, reads files, writes deliverables, and runs commands in a task-scoped sandbox. Agent Team puts a coordinator on a task board, farms independent work out to parallel sub-agents, collects structured reports, and synthesizes the result. Apache-2.0 and free. The sandbox design is the part worth stealing. Shell and file tools share one task-scoped filesystem split three ways: /inputs is read-only, /workspace is working state, and /outputs holds the deliverables that persist. Authorization and sandbox failures are fail-closed, which is the correct default and not the common one. The task board renders live in the sidebar, and you can type while an agent is running to queue a new instruction instead of waiting for it to finish. Install is one command on macOS and Linux, no preinstall step and no hard Docker dependency. The runtime costs nothing; model calls do. It speaks OpenAI-compatible endpoints, so point it at whatever you already pay for, or serve models locally through SGLang. Solo devs: free, and Agent Team is worth an evening if parallel sub-agents interest you. Teams: evaluate it, but read the catch first. The catch is that this is a vendor's harness published to sell you on the vendor's model. The README leads with a limited-time free trial of the Apodex API and the benchmark chart is Apodex's own. Neither of those makes the code bad, and Apache-2.0 with OpenAI-compatible endpoints means you are not locked in. But the project is days old, the evaluation numbers are self-reported, and a framework this young will move under you. If you want a multi-agent runtime you can build on today, look at goose or the broader LangGraph and CrewAI ecosystem instead.

aiac3.8k★

AIAC uses LLMs to generate infrastructure-as-code: Kubernetes manifests, Dockerfiles, CI/CD configs, all from plain English prompts. Instead of looking up the exact syntax for an AWS security group or a Helm chart values file, you describe what you want and AIAC produces the code. Go, Apache 2.0. It's a CLI tool that connects to OpenAI, Amazon Bedrock, or Ollama (for local models). You run aiac get terraform for an s3 bucket with versioning enabled and it returns the HCL. Supports Terraform, Pulumi, CloudFormation, Ansible, Docker, Kubernetes, GitHub Actions, and more. Fully free as a tool, but you pay for the LLM API calls behind it. Using OpenAI's GPT-4, that's roughly $0.01-0.10 per generation depending on complexity. Using Ollama with a local model, it's free but quality varies. Solo developers: useful for scaffolding infrastructure you don't write every day. Saves the 20 minutes of docs-reading for unfamiliar providers. Small to medium teams: helpful for standardizing templates, but review everything it generates; LLMs hallucinate resource attributes. The catch: zero star velocity and the homepage URL points to a Wikipedia article about LLMs, which is not confidence-inspiring. The generated code needs human review; treat it like a first draft, not a production artifact. And if you're already using GitHub Copilot or Claude in your editor, you get this same capability without a separate tool.

ReMe3.5k★

ReMe gives AI agents memory that survives past a single session. Agents forget everything when the context window fills up or a new conversation starts, and ReMe fixes that by storing what matters and feeding it back later. It's free and open source under Apache-2.0. It offers two flavors. The light version keeps memory as plain markdown files organized by date, compresses long conversations into summaries, and trims verbose tool output, no infrastructure required. The vector version uses embeddings to store user preferences, task patterns, and tool experience, then retrieves them by meaning. You wire either into your agent's reasoning loop. The catch: memory for agents is a crowded, unsettled space, and ReMe is one approach among several (mem0 and others compete here). The markdown mode is easy to start with; the vector mode adds an embedding model and a store to run and maintain. Good to try if you're building agents that need to remember. Don't expect a finished standard yet.

Claw3D2.2k★

Claw3D visualizes AI agent activity as a 3D command center you can watch in real time. Agents sit at desks, review code, run standups, and collaborate in an isometric environment you can watch in real time. Picture a visual mission control for your AI workforce. Each agent gets a customizable 3D avatar with a persistent profile. The office has rooms, navigation, animations, and event-driven activity cues. When an agent starts a code review, you see it happen spatially. Built on OpenClaw, MIT licensed. It's early (just hit open source), but the community is already building on it. The catch: this is a visualization layer, not an orchestration framework. Your agents still need something to make them work; Claw3D just shows you what they're doing. And '3D virtual office' is a concept that sounds cooler than it might be useful day-to-day. If you don't need visual monitoring, this adds complexity for aesthetics.

notte2.0k★

Notte lets AI agents interact with websites the way a person would (clicking buttons, filling forms, navigating pages) but through a structured API instead of raw browser automation. If you're building an AI agent that needs to do things on the web (book appointments, fill out forms, scrape dynamic content), Notte handles the browser part. The key difference from regular browser automation (Playwright, Selenium): Notte translates web pages into a format LLMs can understand. Instead of your agent parsing raw HTML, it gets a structured representation of what's on the page and what actions are available. The LLM decides what to do, Notte executes it. Early stage. The concept is strong but the project is young. There's a hosted API (pricing on their site suggests usage-based tiers) and you can self-host the Python package. The catch: you're betting on a small team maintaining a tool that sits between your AI agent and the entire web. Browser automation is fragile by nature. Sites change, CAPTCHAs block, rate limits hit. Notte abstracts some of that pain but can't eliminate it. For production agent workflows, compare against Browser Use and Playwright with your own LLM integration.

OptMem1.5k★

OptMem gives an AI agent permanent memory in about 426 tokens of prompt and a small script. It's a Python CLI, wake, note, and recall, backed by an append-only log with a binary-tree cache for fast compressed retrieval. The compact prompt teaches the agent how to use it, and the storage design does the heavy lifting underneath. The clever part is the architecture, not the surface. Fixed-width, append-only records let it find a memory in a single disk seek even as the log grows, so recall stays fast without a database or a vector store. It's from Victor Taelin, whose work on HVM, Kind, and Bend gives the systems thinking real credibility. Free and open source, for solo builders and teams experimenting with agent memory. The catch is that it's minimalist by design. This is a small, sharp memory CLI plus an integration prompt, not a full memory framework with retrieval strategies and knobs. The value here is the idea and the storage architecture, plug it in for what it is. If you need a rich, configurable memory layer, you'll outgrow it, but as a lean, fast primitive it's a genuinely smart piece of work.

connectonion1.5k★

ConnectOnion is a Python agent framework built on one idea: you write the prompt and the tools, and it handles everything else. Plain functions become tools with no schema writing. The whole thing is Apache 2.0 and free, including the CLI, the prebuilt Gmail, calendar, and browser tools, and a ready-made chat frontend. There is no server to run. It's a pip install, and a working agent is three lines of code. The interesting part is the host function: one call exposes your agent over HTTP and a peer-to-peer relay so other agents can discover and call it. Dangerous operations like shell commands go through a built-in approval system instead of you writing permission logic. Solo builders and small teams get the most here. It's one of the fastest paths from idea to working agent in Python. Larger teams already invested in LangGraph (langchain-ai/langgraph) or CrewAI (crewAIInc/crewAI) won't find a reason to migrate. The catch is maturity. The framework is young, the docs move fast, and the multi-agent relay network is the part most likely to change under you. Build side projects on it today, not your production support bot.

memory-os1.4k★

Memory OS gives an AI agent long-term memory that survives across sessions, and it runs entirely on your own machine. The problem it solves is real: most agents forget everything the moment a conversation ends, so you re-explain the same context every time. This stacks seven layers of memory, from workspace files and a session database up to vector storage in Qdrant and an auto-curated wiki, then pulls the relevant pieces into the prompt before each call. MIT licensed, and it works with OpenAI, Anthropic, OpenRouter, or local Ollama. Running it yourself means standing up Qdrant and wiring the layers in, so the ops burden is moderate, not plug-and-play. The payoff is that your agent's memory is yours: no monthly memory subscription, no data sitting in someone else's vector store. The closest hosted options, mem0, Zep, and Letta, all want a cloud account and a recurring bill. This trades that for hardware you control. Solo builders running a persistent agent and small teams who care where their data lives are the target. If you are already invested in the Hermes Agent ecosystem this is the native memory layer; if you are not, the architecture is the draw more than a drop-in install. The catch is that it is built around Hermes Agent. The seven-layer design is general enough to learn from, but lifting it cleanly into a different agent framework is not free. And memory systems are only as good as their retrieval: inject the wrong context and the agent confidently runs with it.

pi-from-scratch1.2k★

Pi-from-scratch rebuilds a working coding agent, one that reads files, edits code, and runs shell commands, in about 600 lines of TypeScript. It's a deliberate deconstruction of the pi agent framework, delivered as an interactive web tutorial where the code appears progressively as you read, with a trace debugger for stepping through the agent loop. MIT licensed, free, bring an OpenAI-compatible API key. Setup is Node 22 and npm install, or just read the hosted version. The tutorial prose is primarily in Chinese, so non-Chinese readers will lean on translation. Read it if you use coding agents daily and can't explain what happens between your prompt and the file edit. It also works as a skeleton for a custom agent. The upstream pi framework is the production version; Anthropic's and OpenAI's agent SDKs are what you'd actually build on. The catch: this is pedagogy, not infrastructure. Its entire value is that it stays small enough to read in a sitting, which is exactly why nobody should ship it.

tool-ui784★

AI models call tools, and every one of those calls has to be shown to the user somehow. Tool-ui gives you pre-built React components for rendering those tool calls and their results inside a conversation UI. This is a UI component library specifically for AI tool-calling interfaces. Instead of building your own "here's what the AI did" rendering from scratch, you get components that display tool invocations, streaming results, and error states. It's TypeScript, React-based, and designed to plug into assistant-ui (the parent project's chat framework). Completely free. MIT license, and growing fast. Solo developers building AI chat products will save significant time here. If you're already using assistant-ui for your chat interface, this is the natural add-on. Small teams building internal AI tools get a polished UX without designing tool-call rendering from scratch. The catch: it's nascent. That means a small community, potential breaking changes, and limited battle-testing. Tightly coupled to the assistant-ui ecosystem. If you're using a different chat framework, integration will take work.