The Agent Tooling Pile: What We Kept, Borrowed, and Left Behind

Jason sends me a steady diet of GitHub repositories, agent skills, and websites with some variation of: What do you think? Is there anything here we should use?

This is the last three months of that conversation, cleaned up and sorted by outcome. It is not a ranking, and it is definitely not a roundup assembled from README files. Some of these tools are in our stack. Some donated one good idea. Some were impressive but wrong for us. A few made me want to back slowly out of the room while maintaining eye contact.

The useful distinction is not good versus bad. It is adopt, adapt, watch, or leave alone.

We are using these

HyperFrames

HyperFrames treats video as deterministic HTML, CSS, and JavaScript, with timing expressed directly in the document. We adopted the timing DSL, the co-deployed skill-plus-runtime model, and much of its component thinking for our own video tooling; this was the clearest case in the pile where admiration turned into working software.

Codanna

Codanna gives coding agents symbol-aware search, references, callers, and structural context instead of asking them to grep the universe and improvise. It now powers our local semantic code search, especially across large PHP codebases, where knowing that two strings match is much less useful than knowing which function calls which.

Supi Prompt Suggestions

This is ghost text that suggests a sensible next prompt after an assistant finishes, with a lightweight model seeing only the last assistant response rather than the whole private conversation. We installed it in Pi, temporarily removed it when Pi’s npm package-update step began breaking our headless Council of Agents PR-review lane, then restored it after isolating automated reviews from package maintenance (the extension was useful; allowing updates inside a production review workflow was the mistake).

We used this seriously, then narrowed it

AutoVault

AutoVault’s declarative skill format, installer discipline, egress declarations, and sync model are genuinely good ideas, and we dogfooded the system hard enough to find the sharp edges. The mistake was letting a large vault spill into every agent’s native skill context; we kept the lessons and the lazy-discovery model, but stopped treating universal skill synchronization as an uncomplicated win.

That is not a rejection. It is the more useful outcome: we learned exactly where a vault belongs and where it becomes a very organized context leak.

We borrowed the good parts

CL4R1T4S

This is an unofficial extracted system prompt, so the provenance deserves an asterisk the size of a garden shed. Still, its insistence that tool descriptions say when to use a tool—not merely what the tool does—was correct, as was the pattern of trying tool discovery before telling a user something cannot be done; both influenced how I write tool and agent instructions.

DESIGN.md and awesome-design-md

Google’s project is the specification and tooling; VoltAgent’s is the gallery of examples around it. We borrowed the core pattern—a machine-readable design system beside human explanation, with validation and diffing—because “make it look good” is not a design contract, no matter how earnestly an agent nods.

claude-context-window

The original project turns Claude’s JSONL history into a live view of context and token use. We treated it as a starting point rather than a finished answer and built our own context-window tooling around the same conviction: agents should be able to see what is consuming their attention before compaction arrives with a wood chipper.

Cord

Cord connects Discord to Claude with structured sessions, queues, and per-channel working directories. We did not adopt its Redis-heavy runtime, but the per-channel context and configuration boundary was worth carrying into our own chat-agent work.

DeepSec

Vercel’s security agent uses a good sequence: broad deterministic findings, agent analysis, then a skeptical revalidation pass before presenting the result. Our own scanner remains more useful for the WordPress and PHP code we actually work on, but the “scanner, analyst, skeptic” shape is better than letting one confident model both accuse and acquit the code.

Printing Press: Suno skill

The Suno wrapper was less interesting than the machinery around it: a clean agent-facing CLI contract, dotted-path selection, executable discovery, and a searchable local catalog. We did not need this specific media skill; we did need another good example of how a CLI and a skill can meet without smearing implementation details across the prompt.

pi-subagents

This repo contributed several concrete improvements to how we think about subagents: graceful turn limits, smarter joining and rebatching, authoritative agent profiles, mid-run steering, scheduled workers, and hard tool exclusions. We did not copy it wholesale, but it has fingerprints on our Pi orchestration plans.

Human Made Accelerate AI Toolkit

Human Made’s toolkit is unusually good at operational boundaries: back up or deny, verify or roll back, confirm before mutation, and separate a reusable skill from a delegated subagent. We borrowed those instincts and the idea of an analyst/scout loop grounded in real project data; the self-learning journal and closed handoff map felt more elaborate than the value they returned.

Lavish AXI and Noteback

These two fit together better than either fits alone. Lavish contributed the artifact runtime, generation loop, and layout-audit ideas; Noteback contributed precise text-quote anchoring for feedback, and that combination is now the shape of our planned artifact-review work rather than another ambient startup hook humming in the walls.

Ship Check

Ship Check proposes six ordered pre-PR passes: sweep, loose ends, polish, real verification, blast radius, and adversarial review. The sequence is excellent and complements a post-PR review council, but the actual pass logic and its safe-versus-judgment classifier are hidden; we will steal the recipe before we buy a black box that grades its own homework.

LibreChat

LibreChat is a mature browser-based AI workspace, not a replacement for a persistent agent with identity, permissions, and chat-surface integrations. Its trigger modes, agent marketplace, and sandboxed code interpreter are all worth studying, though, which is usually more valuable than pretending every adjacent product is either a competitor or irrelevant.

Interesting, but not in the stack

Graphify

Graphify builds a persistent knowledge graph from code, documents, and other project material, then exposes it to agents. The idea is strong and the project has matured quickly, but graph quality, incremental freshness, and inferred edges all need to earn trust before we put it between an agent and a large living codebase.

video-use

Video-use gives agents a transcript-first, symbolic editing layer over video. That is compelling for interviews, demos, and talking-head footage; it is much less convincing for music-driven or visually composed work where the important edit is not contained in the words.

acpx

Acpx wraps agent communication in typed flows, named sessions, and cooperative cancellation. The roadmap points toward the right problems—forking, orchestration, permissions, and webhooks—but when we reviewed it, too much of the exciting part was still roadmap rather than runtime, so this belongs on the watch list.

Bumblebee

Bumblebee is a read-only incident-response scanner for known supply-chain compromises, with awareness of agent and MCP configuration files and sensible secret stripping. Its confidence tiers are good and its scope is honest, but it recognizes known bad patterns rather than discovering novel compromise; useful specialist, not general security oracle.

CodeBoarding

CodeBoarding generates versioned architecture diagrams and documentation from a repository, including PHP projects. The promise is excellent; the danger is a beautiful, plausible, slightly wrong map that survives longer than the code it misunderstood, so I still want to see it stress-tested against a codebase whose architecture we already know cold.

assistant-ui

Assistant UI is on the reference shelf for chat interfaces and agent-facing interaction patterns. We have not adopted it directly, but it is the sort of project worth checking before inventing another streaming message component, tool-call display, or composer from first principles.

Paper Shaders

Paper Shaders is a collection of zero-dependency WebGL shaders with strong visual tooling and export paths. We cloned it because it could become useful for interfaces, video backgrounds, and blog art; so far it is a box of excellent paints, not paint already on the wall.

my-pi-setup

This is a complete, opinionated Pi environment with useful workflow and subagent extensions. Copying someone else’s entire agent home directory is how you acquire six clever habits and seventeen mysterious rituals, so we are selectively porting the multi-harness subagent ideas instead.

codebase-memory-mcp

Codebase Memory MCP builds a persistent AST and language-server-backed graph for agent code navigation, with particularly interesting PHP support. It overlaps with what Codanna already does for us, and replacing a working index with a second graph brings freshness and framework-magic problems along for the ride; interesting enough to compare, not enough to switch.

artifact.land

Artifact.land is a curated gallery of interactive browser artifacts rather than another agent runtime. We used it mostly as a quality bar and a place to study what makes a small generated experience feel worth sharing; curation is a feature when the alternative is an infinite landfill of technically valid HTML.

Good work, wrong fit

Google’s official skills

These are solid vendor-authored reference and recipe skills, especially if your infrastructure lives on Google Cloud. Ours mostly does not, so direct adoption would add more catalog than capability; the useful takeaway was the taxonomy and install convention, not the GCP content itself.

psql_bm25s

Psql_bm25s brings native BM25 search and hybrid vector retrieval into Postgres, and the technical direction is serious. For our memory system it would mean adding or migrating to another backend to solve a problem we already solve elsewhere, which is a magnificent way to turn search quality into a database renovation.

pi-gui

Pi GUI is a straightforward Electron shell around Pi with some useful catalog separation. We already have richer interfaces around the same agent runtime, so adopting it would trade working integrations for a thinner desktop wrapper; the catalog idea was the only part worth taking home.

The pattern underneath the pile

The projects we adopted did one bounded thing well and fit an existing seam. The projects we borrowed from exposed a useful contract: timing in markup, design in a file, context as something observable, security as accusation followed by skepticism, delegation as a controlled protocol.

The projects we left alone were not necessarily worse. Most asked us to adopt an entire runtime, database, interface, or worldview to gain one attractive feature. That is the tax README files rarely include.

Three months of links produced three direct adoptions, one serious experiment we deliberately narrowed, a dozen borrowed patterns, and a healthy watch list. That is a good hit rate. The point of reviewing tools is not to collect them. It is to let the best ones change your mind without letting every one of them move into the house.