Filesystem and Agents are standalone MCP servers — useful on their own, but purpose-built to pair with Memoryco. When memory is running, each tool registers its operating instructions directly into your knowledge base, so your AI knows exactly how to use them without being told twice.
Most filesystem MCPs are thin wrappers. This one adds a full semantic index — your AI can ask "where is authentication handled?" and get a meaningful answer instead of grepping through 3,000 files.
All operations are sandboxed to explicitly allowed directories. Symlinks are resolved, path traversal is blocked, and tilde expansion just works. You define the boundaries; the AI works inside them.
When Memoryco is running, Filesystem registers its usage guide directly into
your memory home — your AI learns the difference between
search_semantic
and search_files
and will use them correctly, automatically.
$ curl -fsSL https://memoryco.ai/install_fs.sh | sh
$ memoryco_fs install
Find code by what it does, not what it's named. Powered by local embeddings — no API calls, no data leaving your machine.
Read specific line ranges, heads, or tails. Combine with semantic search for fast, precise code retrieval without loading entire files.
Recursive directory trees with configurable depth, entry limits, and exclude patterns. Human-readable output, like the tree CLI.
Line-based text replacements with exact-match enforcement. Returns a diff so your AI can verify every change it makes.
Browser-based view of your indexed directories, semantic index health, and sandbox boundaries. Open it from any MCP client.
All listing tools have configurable limits and offsets. Large codebases won't blow up your context window or your response times.
| Tool | Description | Type |
|---|---|---|
| read_text_file | Read file contents with optional line range, head, or tail | read |
| read_multiple_files | Read multiple files simultaneously | read |
| read_media_file | Read binary files as base64 with MIME type | read |
| list_directory | List directory contents with pagination | read |
| list_directory_with_sizes | Directory listing including file sizes, sortable | read |
| directory_tree | Recursive tree view with depth and exclude controls | read |
| search_files | Glob pattern search across the filesystem | read |
| search_semantic | Find code by meaning using local vector embeddings | semantic |
| get_file_info | File metadata: size, timestamps, permissions | read |
| list_allowed_directories | Show the current sandbox boundaries | read |
| write_file | Create or overwrite files | write |
| edit_file | Targeted line-based text replacements, returns diff | write |
| create_directory | Create directories recursively (mkdir -p style) | write |
| move_file | Move or rename files and directories | write |
| open_dashboard | Open the filesystem dashboard in your browser | control |
Spawn a Claude Code instance to work on a task in a specific directory, then keep talking while it runs. Check its progress, send follow-up messages, or kill it if it goes sideways — all through MCP tools.
Agent types let you define reusable specialized workers: a code reviewer that only has read access, a documentation writer scoped to specific tools, a debugger with full bash. Save them once, invoke them by name.
When Memoryco is running, Agents registers its operational guide into your memory home — your AI knows exactly when to delegate, how to write a good spawning prompt, and when to check back for results.
$ curl -fsSL https://memoryco.ai/install_agents.sh | sh
$ memoryco_agents install
Launch a Claude Code instance to work in a directory. Your conversation keeps going. One agent per directory — no pile-ups.
Send follow-up messages to a running agent. Course-correct mid-task without killing and restarting the whole thing.
See what tools the agent has called, what it's working on, stderr output, and final results when it's done.
SIGTERM or SIGKILL — you decide. Running agents are tracked with proper lifecycle management. No zombie processes.
Define reusable agent archetypes with custom system prompts, model selection, and scoped tool access. Stored as portable markdown.
Browser-based view of all running and completed agents. Activity logs, output previews, and status at a glance.
Define a specialized agent once as a markdown file with YAML frontmatter. Give it a focused system prompt, scope its tools, pick a model. Then spawn it by name from any conversation.
Types live in ~/.claude/agents/ —
the same place Claude Code's native subagents look. They work as
MemoryCo background agents and as Claude Code subagents.
Generate new types with AI, improve existing ones, or write them by hand. Portable markdown files that travel with your dotfiles.
| Tool | Description | Type |
|---|---|---|
| agent_spawn | Spawn a background Claude Code instance with a prompt and working directory | control |
| agent_list | List all tracked agents with current status | read |
| agent_status | Detailed view of one agent: output, activity log, stderr | read |
| agent_respond | Send a follow-up message to a running agent | control |
| agent_kill | Terminate a running agent (SIGTERM or SIGKILL) | control |
| agent_types_list | List available agent types from ~/.claude/agents/ | read |
| agent_types_get | Get the full definition of a specific agent type | read |
| open_dashboard | Open the live agents dashboard in your browser | control |
Both tools ship with a plugin_instructions.md
— a concise operating guide for how and when to use each tool effectively.
When Memoryco is running, these instructions are automatically registered into your memory home on startup. Your AI absorbs them through normal recall — no manual prompting, no copy-pasting docs into context.
The result: an AI that reaches for search_semantic
when exploring code, and knows to spawn an agent instead of blocking
your conversation on a long-running task.
Your memory home is initialized at ~/.memoryco/. The bootstrap system is ready.
Each tool registers a plugin manifest in bootstrap.d/ on first run.
On startup, memoryco reads all bootstrap manifests and injects their usage guides into context.
No system prompt edits. No repeated instructions. The tools work the way they should, immediately.
memoryco_fs and memoryco_agents are free. Pair them with Memoryco for the full picture.