Detailed Analysis
A Reddit post from developer Andriy Viyatyk details a self-built solution to a persistent annoyance in agentic coding workflows: Claude Code's tendency to reinvent the wheel every session. The tool, called Agent Tools, is part of a broader open-source project named Persephone, described as a free developer notepad built using Claude Code itself. The core insight is straightforward but addresses a real inefficiency—when Claude is asked to perform recurring tasks like querying a database or hitting an internal API, it writes a fresh ad-hoc script each time, debugs it in-session, and then discards it once the conversation ends. Agent Tools converts these disposable scripts into a persistent, searchable library that Claude can draw on across sessions, effectively giving the model a long-term memory for its own tooling.
The architecture is notable for its simplicity. Each "tool" is just a script (in Python, JavaScript, PowerShell, or shell) paired with a manifest entry describing its name, purpose, argument schema, and keywords. These are grouped into portable "toolsets"—self-contained folders that can be copied to another machine and registered there. Rather than exposing every individual tool as a separate MCP (Model Context Protocol) function—which would bloat Claude's available schema as the library grows—the system exposes only two meta-tools: search_tools, which takes a natural-language query and returns ranked, ready-to-call tool definitions, and execute_tool, which runs a specific tool by ID with JSON arguments. This design keeps the MCP surface constant regardless of how many tools accumulate, sidestepping a scaling problem that would otherwise make large tool libraries unwieldy for the model to reason about.
Security and reliability are handled through a few deliberate constraints. Secrets are stored in .env files adjacent to each script, meaning credential values never pass through MCP or become visible to the agent—only variable names are exposed. This is a meaningful detail for anyone running Claude Code against internal systems or APIs with sensitive credentials, since it limits the blast radius of prompt injection or accidental leakage through model context. The system also builds in a self-healing loop: when a tool fails, the error result includes the script's file path and stderr output, allowing Claude to navigate to the folder, patch the script, and retry—so tools improve over time rather than being silently worked around with new one-off code. New tools are created through a similar feedback mechanism: after Claude successfully improvises a solution to a repeatable problem, it can offer to formalize it into a tool via a create_toolset scaffolding function, but registration always requires explicit user confirmation, creating a trust gate that prevents unvetted scripts from running autonomously.
This project reflects a broader trend in the Claude Code and agentic-AI ecosystem: developers are increasingly building infrastructure layers around foundation models to compensate for their lack of persistent state between sessions. Rather than waiting for Anthropic to solve memory and tool-reuse natively, community members are shipping MCP-based extensions that give Claude durable capabilities—file systems, tool registries, task boards (referenced here as an "earlier Boards post" from the same author)—that accumulate value the more they're used. The two-meta-tool pattern (search + execute) is itself an emerging best practice among MCP tool builders, since it avoids the context-window and schema-complexity costs of registering dozens or hundreds of discrete functions directly with the model. Projects like Persephone and Agent Tools illustrate how open-source contributors are treating Claude Code less as a single chat interface and more as a programmable runtime, building the kind of scaffolding—memory, self-correction, trust boundaries—that turns a stateless coding assistant into something closer to a persistent, improving software agent.
Read original article →