Agent Stack: choose, integrate and evaluate agent tools

obra/superpowers · Integration complexity: Low · Reviewed 2026-10-17

A software development methodology for coding agents, delivered as a set of composable skills plus initial instructions that make the agent use them.

Why it matters

It is a worked example of treating agent behaviour as versioned, reviewable files. Reading it teaches how far skills can steer a workflow, and where they cannot.

Cost and latency

Skill text adds input tokens whenever it is loaded. Heavier process means more turns per task. Measure both rather than assuming a net saving.

Use cases

• Imposing a consistent plan, implement, review workflow on a coding agent
• Team-wide conventions delivered as skills rather than a long system prompt
• Trying structured methodology before writing your own skills

Strengths

• Opinionated end-to-end workflow rather than a loose pile of prompts
• README lists install paths for many agent clients, so skills are portable across tools
• MIT licence

Limitations

• Methodology is the author's; it may conflict with your team's process
• More skills loaded means more instructions competing for the model's attention
• Effect on your tasks is unmeasured until you test it (see the lab)

Security and trust

• Skills are instructions the agent follows with your permissions; read them before installing
• Pin to a tag or commit rather than tracking the default branch
• Check what scripts or commands any bundled skill tells the agent to run

Maintenance

Actively developed upstream; the README documents an update procedure. Plan to re-test after updates.

When not to use it

When your team already has a documented workflow the agent follows, or when the task is small enough that process overhead exceeds the work.

Alternatives

mattpocock/skills; Writing your own small skills; A plain CLAUDE.md or AGENTS.md

Learn on this site

• Guide: agent skills and harnesses
• Lab: measure agent skills
• Agentic AI Engineering path

mattpocock/skills · Integration complexity: Low · Reviewed 2026-10-17

The author's own agent skills for day-to-day engineering. The README describes them as small, adaptable and composable, and positions them against heavier process frameworks.

Why it matters

Small skills you can read in a few minutes are easier to audit and debug than a large framework. It shows the lighter end of the design space.

Cost and latency

Small skills keep the added context modest. Measure on your own tasks.

Use cases

• Starting point to copy and adapt, not a framework to adopt wholesale
• Learning what well-scoped single-purpose skills look like

Strengths

• Small and readable, so the security review is quick
• Per the README, intended to work with any model
• MIT licence

Limitations

• Reflects one engineer's workflow; adaptation is expected
• Not a maintained product with support commitments

Security and trust

• Read each skill before use
• Copy rather than auto-sync if you need a stable baseline
• Pin to a commit

Maintenance

Personal repository; assume you own your fork once adopted.

When not to use it

When you need an enforced, centrally managed process across many teams.

Alternatives

obra/superpowers; Your own skills

Learn on this site

• Guide: agent skills and harnesses
• Lab: measure agent skills
• Agentic AI Engineering path

affaan-m/ECC · Integration complexity: High · Reviewed 2026-10-17

An agent harness performance optimisation system: skills, instincts, memory, hooks and security configuration for Claude Code, Codex, OpenCode and other agent clients. Formerly named everything-claude-code.

Why it matters

It shows what a fully configured harness looks like, including the failure mode of having too much of it.

Cost and latency

Each enabled skill, rule and hook adds context or latency. The cost grows with how much you enable; audit what loads at session start.

Use cases

• Bootstrapping a complete harness configuration quickly
• Studying hooks, sub-agents and command layouts at scale
• Cherry-picking individual skills or hooks into your own setup

Strengths

• Breadth: skills, hooks, agents, commands and rules in one place
• Multi-client orientation
• MIT licence

Limitations

• Large surface area; installing everything inflates context and is hard to audit
• Hooks execute shell commands on your machine
• Fast-moving; naming and layout have changed (the project was renamed)

Security and trust

• Hooks run with your user permissions on tool events; review every hook before enabling
• Prefer installing a minimal subset
• Pin versions and diff on update
• Keep secrets out of the working directory and out of any memory it writes

Maintenance

Very active. Expect churn; treat updates like dependency upgrades.

When not to use it

When you want a minimal, auditable setup, or when your security policy forbids third-party hooks.

Alternatives

Hand-written settings, hooks and CLAUDE.md; obra/superpowers; ruvnet/ruflo

Learn on this site

• Guide: agent skills and harnesses
• Lab: measure agent skills
• Guardrail layer pattern

ruvnet/ruflo · Integration complexity: High · Reviewed 2026-10-17

Described in its README as an agent meta-harness for Claude Code and Codex, with multi-agent swarm orchestration. Formerly claude-flow. Distributed as plugins, an npx initialiser and an MCP server.

Why it matters

Multi-agent orchestration multiplies cost and failure modes. It is useful to study how a swarm tool structures them, and to learn when a single agent is enough.

Cost and latency

Several agents mean several concurrent context windows. Token spend scales roughly with agent count times task length; set budgets and caps.

Use cases

• Experimenting with multi-agent coordination on larger tasks
• Routing and policy enforcement inside Claude Code via its mods

Strengths

• Several integration routes (plugins, MCP, CLI)
• MIT licence
• README warns that mods run with your account's permissions and should be reviewed

Limitations

• Very broad scope; harder to reason about than a single loop
• README performance and download figures are vendor claims we have not verified
• Hook support depends on the client

Security and trust

• Mods run with your account permissions; the README says to review their code
• An MCP server exposes tools to the model; scope what it can reach
• Run first in a throwaway repository or container

Maintenance

Active with frequent changes and a rename in its history. Pin versions rather than using @latest in anything repeatable.

When not to use it

Before you have a single-agent loop with evals. Orchestration on top of an unmeasured agent hides which part is failing.

Alternatives

A single agent with sub-agents defined in your harness; Plain scripts that fan out tasks; Frameworks in the agent system pattern

Learn on this site

• Agent system pattern
• Challenge: agent tool error cascade
• Challenge: cost blowup after launch
• Lab: build an agent loop

mksglu/context-mode · Integration complexity: Medium · Reviewed 2026-10-17

An MCP server and plugin that, per its README, keeps raw tool output out of the context window by running it in a sandbox, and tracks session events in SQLite so work can resume after compaction.

Why it matters

Context is the scarce resource in agent work. Tool output is often the largest consumer, so intercepting it is a legitimate lever.

Cost and latency

Can reduce input tokens when tool outputs are large (vendor claim; verify). Adds hook and sandbox overhead per tool call.

Use cases

• Long coding sessions where large tool outputs fill the context
• Continuity across context compaction

Strengths

• Targets a real cost driver (verbose tool results)
• The README describes a think-in-code pattern: have the agent write a script and print only the result
• Works through hooks on platforms that support them

Limitations

• The README's large reduction figures are the vendor's own and depend on workload; measure on yours
• Adds a moving part between the agent and its tools
• Not an OSI open-source licence

Security and trust

• Hooks and the MCP server see all tool output, which may include secrets and private code: high trust required
• Event history stored locally in SQLite may contain sensitive data; know where it lives and exclude it from version control
• Review the code and pin the version

Maintenance

Active. Requires a recent Claude Code version per the README.

When not to use it

When your tool outputs are already small, when policy forbids a component that sees all tool output, or when you cannot accept a source-available licence.

Alternatives

Manual context hygiene and /compact; Smaller tool outputs by design (pagination, filters); Letta memory; Graphify

Learn on this site

• Guide: agent skills and harnesses
• Challenge: cost blowup after launch
• Lab: add observability

Graphify-Labs/graphify · Integration complexity: Low · Reviewed 2026-10-17

A Claude Code skill that reads a folder (code, documents, images) and builds a queryable knowledge graph, writing a persistent graph.json, a report and optional wiki pages.

Why it matters

A precomputed structure lets an agent ask a narrow question instead of reading broadly. The trade-off is staleness and the cost of building it.

Cost and latency

Build cost is paid up front (model calls for non-code content). Query cost is lower than broad file reads, for questions the graph can answer.

Use cases

• Navigating an unfamiliar codebase by querying relationships instead of reading files
• Giving an agent a persistent map of a repository

Strengths

• Persistent output on disk you can inspect
• Content hashing means re-runs process changed files only (per README)
• Apache-2.0

Limitations

• Non-code extraction uses a model, so it costs tokens and can be wrong; the README says it distinguishes found from guessed relationships
• The README's 71.5x token figure is a vendor claim
• Graph goes stale unless updated

Security and trust

• Document and image extraction sends content to a model: do not run it over confidential material without approval
• Generated files may reveal repository structure; do not publish them unintentionally

Maintenance

Active; the PyPI package name is temporarily different from the CLI name per the README.

When not to use it

Small repositories where grep is enough, or when the graph's upkeep would exceed its benefit.

Alternatives

ripgrep plus good file layout; xerj; Language-server based tools

Learn on this site

• Challenge: cost blowup after launch
• Project: research agent
• Agentic AI Engineering path

JuliusBrussee/caveman · Integration complexity: Low · Reviewed 2026-10-17

A token-reduction skill and proxy that makes an agent write terser output and read less. The README presents measured session results from its own tests.

Why it matters

Output style is a cheap lever, but terse output can reduce clarity and review quality. This is a good subject for a controlled test.

Cost and latency

Fewer output tokens usually means lower cost and latency per turn. Whether answers stay correct is the question to measure.

Use cases

• Reducing output verbosity in long agent sessions
• Experimenting with terse-style prompting to cut spend

Strengths

• Simple idea, easy to switch on and off
• Apache-2.0
• README reports its own methodology, which you can rerun

Limitations

• Reported savings are the author's, on their tasks
• Terse responses can hide reasoning you need to review
• Overlaps with prompt-level style instructions you can write yourself

Security and trust

• A proxy sits on your traffic: confirm what it logs and where it sends data
• Read the skill text before installing

Maintenance

Active, community-driven.

When not to use it

Where explanation quality matters (onboarding, audits) or where you cannot place an extra proxy in the path.

Alternatives

A style instruction in CLAUDE.md or AGENTS.md; Context Mode (a different lever: input size)

Learn on this site

• Lab: measure agent skills
• Challenge: cost blowup after launch

xerj-org/xerj · Integration complexity: Medium · Reviewed 2026-10-17

A Rust tool that automatically indexes a folder for local search so a coding agent can retrieve the code it needs rather than reading files one by one. It can wire itself into agent clients over MCP.

Why it matters

Retrieval beats exhaustive reading when a corpus is big. It is a concrete case of the RAG pattern applied to developer tooling.

Cost and latency

Index build time and disk use up front; lower tokens per query if retrieval is accurate. Measure retrieval quality, not just token count.

Use cases

• Agent search over a large local repository or document set
• Retrieving reference implementations before writing code (a README use case)

Strengths

• Local indexing; Apache-2.0
• Rust implementation
• One-command client wiring per README

Limitations

• Young project (created June 2026) with little track record
• README token-saving figures come from the vendor's own case study and user reports; unverified here
• The README's suggested install pipes a script from the web into a shell

Security and trust

• Do not pipe a remote script into a shell without reading it; download, inspect and pin instead
• The quick-start flag shown in the README disables a check (--insecure); understand it before copying
• Downloading and indexing third-party repositories brings in untrusted content that can carry prompt injection

Maintenance

New; expect rapid change and rough edges.

When not to use it

Production workflows that need a stable, reviewed dependency, or small codebases where grep suffices.

Alternatives

ripgrep; Graphify; A standard vector store as in the RAG pattern

Learn on this site

• Pattern: RAG system
• Challenge: prompt injection via RAG
• Lab: embeddings and vector search

HKUDS/CLI-Anything · Integration complexity: Medium · Reviewed 2026-10-17

Generates command-line interfaces so existing software can be driven by agents. The README describes a hub of community-built CLIs and per-CLI skill files.

Why it matters

Agents are far more reliable with a structured CLI than with screen-driving. Generated CLIs are an attractive but under-reviewed shortcut.

Cost and latency

Calls are local and cheap; the cost is in the extra tool descriptions added to the agent's context.

Use cases

• Giving an agent a scriptable interface to desktop or GUI-centric software
• Reusing a community-contributed CLI instead of building one

Strengths

• Large catalogue of target applications per its README
• Apache-2.0
• Skills installable per CLI

Limitations

• Quality varies across community-contributed CLIs
• A generated CLI is only as safe as the permissions of the software behind it
• Last push 2026-09-22 at review time; check recent activity

Security and trust

• Each CLI is third-party code that can read and write what the target application can
• The README itself records path-traversal and symlink hardening fixes: treat such CLIs as untrusted until reviewed
• Prefer read-only modes and test on copies of data

Maintenance

Community project; per-CLI maintenance quality will differ.

When not to use it

When the software already has a supported API or MCP server, or the data is irreplaceable and you cannot test on a copy.

Alternatives

Official APIs; MCP servers from the vendor; browser-use for web apps

Learn on this site

• Challenge: agent tool error cascade
• Guardrail layer pattern
• Lab: build an agent loop

morluto/rea · Integration complexity: High · Reviewed 2026-10-17

One MCP server for reverse engineering across binaries, applications and runtime behaviour, distributed on npm. It is a dual-use tool; this site does not provide a how-to for it.

Why it matters

It illustrates how MCP can expose powerful analysis tooling to an agent, and why authorisation must be settled before the agent is pointed at anything.

Cost and latency

Analysis tasks can be long and token-heavy; budget accordingly.

Use cases

• Authorised security research and interoperability work
• Understanding software you own or are permitted to examine

Strengths

• Single MCP surface for varied analysis tasks per its README
• MIT licence
• README states permitted purposes: lawful research, education, interoperability, software preservation, and analysis of software you own or are authorised to examine

Limitations

• Young project (created April 2026)
• Commercial analysis tools it integrates with require their own lawful licences, per the README
• Output from an agent analysing binaries needs expert verification

Security and trust

• The README notes runtime guides execute with your user permissions
• Analysing malware or unknown binaries requires an isolated VM or container with no network access to anything valuable
• Do not run it on software you are not authorised to examine

Maintenance

New; expect change.

When not to use it

Without written authorisation or clear legal right to examine the target. Also not for circumventing licence checks, DRM or access controls, or analysing a third party's confidential software.

Alternatives

Established disassemblers and debuggers used by a qualified analyst; Vendor documentation and APIs

Learn on this site

• Guardrail layer pattern
• Human-in-the-loop pattern

K-Dense-AI/scientific-agent-skills · Integration complexity: Medium · Reviewed 2026-10-17

A library of scientific skills for agents (the README claims 177 skills and over 100 databases). Formerly claude-scientific-skills. It follows the Agent Skills convention and the README mentions an automated security scan.

Why it matters

Domain skills encode procedure, but scientific output needs verification by a domain expert. The library shows both the value and the risk.

Cost and latency

Loading many skills bloats context. Enable only the relevant few per project.

Use cases

• Bioinformatics, chemistry and data-analysis workflows with an agent
• A reference for how to structure domain skills

Strengths

• Broad coverage per its README
• MIT licence
• CI workflows for security scanning and skill tests are visible in the repository

Limitations

• Skill count is a README claim; individual skill quality will vary
• An agent following a skill can still produce plausible but wrong science
• Large library: load only what you need

Security and trust

• Skills can instruct the agent to run code and call external databases
• Keep patient or proprietary data out of third-party APIs unless approved
• A scan badge is not an audit: read the skills you use

Maintenance

Active with versioned releases per its README.

When not to use it

For regulated or clinical decisions without expert review, or when data governance prohibits external calls.

Alternatives

Domain-specific pipelines such as Nextflow; Hand-written analysis notebooks

Learn on this site

• Project: research agent
• Lab: build an eval pipeline
• AI for Everyone: agents

debpalash/VoiceStudio · Integration complexity: Medium · Reviewed 2026-10-17

Open-source local voice cloning, voice design, video dubbing, dictation, transcription and audiobook creation, positioned as an alternative to hosted services such as ElevenLabs.

Why it matters

Local processing avoids sending audio to a vendor, which matters for privacy. Voice cloning, however, carries consent and fraud risk regardless of where it runs.

Cost and latency

No per-call fee; cost is local compute and time. Larger models need capable hardware.

Use cases

• On-device dictation and transcription
• Dubbing and narration with voices you have rights to

Strengths

• Runs locally, so audio can stay on your machine
• Wide feature set in one app

Limitations

• AGPL-3.0: if you modify it and offer it over a network, you must offer the source to users
• Quality, language coverage and hardware needs are not independently verified here
• Cloning a voice without the speaker's consent can be unlawful or fraudulent

Security and trust

• Clone only voices you own or have written consent to use
• Disclose synthetic audio where required or expected
• Check model weights' own licences, which can differ from the app's
• Download releases only from the official repository and verify checksums if provided

Maintenance

Active. Verify current release status before depending on it.

When not to use it

When you cannot obtain consent for a voice, when AGPL obligations conflict with your product plans, or when you need a vendor SLA.

Alternatives

Whisper for transcription (MIT); Kokoro for speech synthesis (Apache-2.0); Hosted voice APIs with contractual terms

Learn on this site

• Local AI
• API versus local

browser-use/browser-use · Integration complexity: Medium · Reviewed 2026-10-17

A library for letting an AI agent operate a web browser, with an MCP server entry and a hosted cloud offering from the same team.

Why it matters

Browser agents read untrusted pages, so prompt injection is the central risk. It is a good subject for the guardrail and human-in-the-loop patterns.

Cost and latency

Each step involves a model call over page state, so cost and latency scale with task length. Cap steps and spend.

Use cases

• Automating web tasks that have no API
• Agent-driven testing and data gathering within a site's terms

Strengths

• Widely used approach to web agents
• MIT licence
• Self-hosted or cloud options

Limitations

• Slower and costlier per step than API calls
• Websites change; scripts and flows break
• Bot detection and site terms may prohibit automation

Security and trust

• Pages can embed instructions aimed at the agent; never give it credentials or actions it should not take on untrusted sites
• Use a dedicated browser profile with no saved logins
• Require human approval for purchases, sends and deletes

Maintenance

Active.

When not to use it

When a documented API exists, or when the site's terms forbid automated access.

Alternatives

Official APIs; Playwright scripts without an agent; Vendor-hosted computer-use features

Learn on this site

• Challenge: prompt injection via RAG
• Human-in-the-loop pattern
• Challenge: cost blowup after launch

letta-ai/letta · Integration complexity: High · Reviewed 2026-10-17

Stateful agents with memory that can learn over time (formerly MemGPT). The README says current source lives in letta-ai/letta-code, which includes the agent harness, terminal UI and App Server.

Why it matters

Persistent memory is useful and risky: stored content can be wrong, stale or poisoned. It is the clearest case for designing memory deliberately.

Cost and latency

Memory retrieval and updates add calls and tokens per turn. Measure against a stateless baseline.

Use cases

• Long-lived assistants that remember across sessions
• Embedding stateful agents into a TypeScript application via its Agent SDK

Strengths

• Memory is a first-class concept
• Self-hosted server or hosted option per README
• Apache-2.0

Limitations

• Repository structure has moved (check which repo to follow)
• Persistent memory needs governance: retention, correction, deletion
• More infrastructure than a stateless loop

Security and trust

• Memory can store personal data and secrets: define what may be written
• Untrusted input can be written to memory and influence later runs (memory poisoning)
• Check data residency if using the hosted option

Maintenance

Active; follow the repository the README points to.

When not to use it

When each task is independent, or when you cannot meet your privacy obligations for stored conversation data.

Alternatives

A simple database or files for explicit state; Context Mode (session continuity only)

Learn on this site

• Production agent pattern
• Lab: add observability
• Agent design reference

NousResearch/hermes-agent · Integration complexity: Medium · Reviewed 2026-10-17

A general agent from Nous Research that, per its README, has a built-in learning loop: it creates and improves skills from experience and searches past conversations. It works with many model providers.

Why it matters

Self-modifying skills raise the stakes for review and rollback: the instructions that steer the agent can change without you writing them.

Cost and latency

Depends on the provider and model you choose. Learning-loop activity adds tokens; measure.

Use cases

• A model-agnostic personal or team agent
• Studying agents that write their own skills

Strengths

• Provider-agnostic per README
• MIT licence
• Native Windows and Unix installs documented

Limitations

• Self-improvement claims are the vendor's and need your own measurement
• Learned skills can drift or encode mistakes
• The README's install method pipes a remote script to a shell

Security and trust

• Inspect the install script before running; do not pipe unread scripts into a shell
• Review and version-control any skills the agent writes for itself
• Run with least privilege and a scoped working directory

Maintenance

Active.

When not to use it

When you need deterministic, audited behaviour, since self-updating skills change the system over time.

Alternatives

Fixed, reviewed skills in your own harness; Letta

Learn on this site

• Production agent pattern
• Lab: build an eval pipeline
• Guide: agent skills and harnesses