Replaceables Core

The compound intelligence layer for agentic engineering — persistent memory, autonomous execution, self-learning workflows, and enterprise-grade observability. One MCP server. Zero configuration. Every session smarter than the last.

Replaceables Core is a production-grade Model Context Protocol (MCP) server that transforms Kiro into a fully autonomous, self-improving engineering system. It gives your AI coding assistant capabilities that don't exist out of the box: persistent cross-session memory, multi-agent coordination, autonomous task execution, compound intelligence that grows exponentially across sessions, and real-time observability into everything happening under the hood.

Install it once. It works immediately with zero configuration — adapting automatically to your project's maturity, learning from every interaction, and reducing costs by up to 80% through intelligent tool routing and response caching.

What it solves: AI assistants are stateless. Every session starts from scratch — you re-explain architecture, repeat conventions, and watch it make the same mistakes. Replaceables Core eliminates that entirely. Your assistant remembers, learns, coordinates multi-step work autonomously, and becomes measurably better at your codebase over time.

How it works: Replaceables Core sits between your IDE and your codebase as an intelligent coordination layer. It intercepts tool calls and injects persistent memory, dynamic routing, semantic caching, and neural learning — turning ephemeral LLM sessions into a compounding system. Every session automatically captures what you worked on (files modified, commands run, patterns searched) and stores it for future retrieval. When patterns reach high confidence, they're automatically synthesized into reusable skills. When tasks require coordination, specialized agents (coder, tester, reviewer, orchestrator) execute them with safety gates and full audit trails.

Who it's for: Solo developers tired of repeating themselves. Engineering teams who want shared intelligence across projects. Organizations that need enterprise accountability for AI-assisted development. Anyone using Kiro who wants dramatically better results with less effort.

🚀 New in v1.0.28: Session Digest — Guaranteed automatic memory population. Every meaningful session now stores a structured digest at shutdown (files modified, commands run, search patterns) without any agent cooperation. "Zero configuration, every session smarter than the last" is now truly automatic.

Why Replaceables Core?

| Without Replaceables Core (vanilla Kiro) | With Replaceables Core | |-------------------------------|--------------| | Every session starts from scratch | Your AI remembers everything across sessions — decisions, patterns, preferences | | One agent does everything | 4 specialized agents (orchestrator, coder, tester, reviewer) working autonomously | | Makes the same mistakes repeatedly | Learns from failures, synthesizes skills, never repeats them | | Loads 197+ tools every turn (~15K wasted tokens) | Smart tool routing saves ~80% — only loads what's relevant | | You manage context manually | Automatic — captures, saves, restores, and compounds knowledge every session without any intervention | | No coordination between tasks | Plans work via GOAP, executes via agent pipelines, tracks progress across sessions | | No visibility into AI decisions | Live dashboard, deterministic replay, health scoring, full audit trail |

Quick Start

# Install and initialize in your project
npx @replaceables/core init

That's it. Replaceables Core generates everything needed:

.kiro/
├── settings/mcp.json          ← Registers Replaceables Core as Kiro's MCP server
├── agents/                    ← 4 specialized agents ready to use
├── skills/                    ← Memory management + task coordination skills
├── hooks/core-lifecycle.json  ← 5 lifecycle hooks for auto-persistence
└── steering/core-rules.md     ← Behavioral rules for agent coordination

.core/                         ← Runtime data (auto-gitignored)

Open your project in Kiro, and everything works automatically.

Guaranteed memory population: Every session that does meaningful work (3+ tool calls, 2+ different tools) automatically stores a session digest in memory at shutdown. You never need to manually call memory_store — the system captures what files you modified, what commands you ran, what you searched for, and stores it for future sessions. This is what makes "every session smarter than the last" actually work without any agent cooperation.

Adaptive behavior: Replaceables Core detects your project's maturity and adjusts automatically — lighter footprint for new projects (fewer tools, less overhead), full orchestration power for established codebases. No configuration needed.

Real-World Scenarios

Scenario 1: "I keep re-explaining my project architecture"

The problem: Every time you start a new Kiro session, you have to remind the agent about your tech stack, conventions, past decisions, and project structure.

With Replaceables Core: The first time you explain your architecture, Core stores it in persistent memory. Next session, the agent automatically retrieves it. You never explain the same thing twice. Even if you don't explicitly ask it to remember, Session Digest automatically captures what files you modified and what you worked on — so the next session knows what happened.

You: "Remember, we use React Query for server state and Zustand for client state"
→ Replaceables Core stores this in memory with tags: [architecture, state-management, react]

Next session:
You: "Add a new API endpoint with proper state management"
→ Replaceables Core retrieves your conventions automatically before the agent starts working

Even without explicit "remember" commands:
→ Session Digest auto-stores: files modified, commands run, patterns searched
→ Next session can see what you worked on previously

Scenario 2: "My agent keeps making the same mistakes"

The problem: Your agent tries an approach that fails (wrong import path, deprecated API, incompatible library version), and will make the same mistake in future sessions.

With Replaceables Core: The intelligence pipeline automatically learns from failures. When a pattern is seen enough times, it becomes a learned skill that prevents the mistake from recurring.

Session 1: Agent tries `import { render } from '@testing-library/react'` → fails
           Agent discovers it should be `import { render } from '@testing-library/react/pure'`
           → Replaceables Core records this pattern

Session 5: Same situation arises
           → Agent already knows the correct import (pattern was consolidated into a skill)

Scenario 3: "I need coordinated work across multiple files"

The problem: A feature touches the API layer, database schema, frontend component, and tests. You want them done coherently, not piecemeal.

With Replaceables Core: Create a goal, and the GOAP planner decomposes it into ordered steps. Track progress across sessions with drift detection.

You: "Create a user invitation system with email sending"
→ Replaceables Core creates a goal, decomposes into:
  1. Design database schema for invitations
  2. Create API endpoint for sending invites
  3. Wire up email service integration
  4. Build frontend invitation form
  5. Write integration tests
→ Progress tracked automatically, picks up where you left off next session

Scenario 4: "Token costs are eating my budget"

The problem: Kiro loads all available tool schemas into context every turn. With 197 tools, that's ~15,000 tokens of tool definitions burning your context window — even when you're just asking about memory storage.

With Replaceables Core's Tool Attention: Only ~12 relevant tools get full schemas per turn. The rest are represented as compact one-line summaries. If the agent needs a tool that wasn't loaded, it can discover it on demand.

You: "Store this decision in memory"
→ Tool Attention promotes: memory_store, memory_search, memory_list, etc.
→ Browser, workflow, federation tools → compact summaries (saving ~12,000 tokens)
→ 80%+ reduction in per-turn tool overhead

Scenario 5: "I want my agent to work autonomously on a task list"

The problem: You have a multi-step refactoring task. You don't want to babysit each step.

With Replaceables Core: Enable autopilot mode. The agent predicts the next action, executes it, learns from the outcome, and continues until the goal is met.

You: "Refactor all API handlers to use the new validation middleware"
→ Enable autopilot
→ Agent: predicts next file → applies pattern → verifies build → moves to next
→ Learns which patterns work → applies them faster on subsequent files
→ Stops when all handlers are converted

Architecture

┌─────────────────────────────────────────────────────┐
│                    Your IDE (Kiro)                    │
└───────────────────────┬─────────────────────────────┘
                        │ MCP Protocol (stdio)
                        ▼
┌─────────────────────────────────────────────────────┐
│           Replaceables Core MCP Server               │
│                                                       │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐  │
│  │Tool Attention│  │   Memory     │  │  Neural   │  │
│  │(smart gating)│  │(persistent)  │  │(learning) │  │
│  └──────────────┘  └──────────────┘  └───────────┘  │
│                                                       │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐  │
│  │   Agents     │  │    Tasks     │  │   Goals   │  │
│  │(coordination)│  │ (tracking)   │  │  (GOAP)   │  │
│  └──────────────┘  └──────────────┘  └───────────┘  │
│                                                       │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐  │
│  │  Autopilot   │  │  Security    │  │  Plugins  │  │
│  │(autonomous)  │  │(protection)  │  │(extend)   │  │
│  └──────────────┘  └──────────────┘  └───────────┘  │
└─────────────────────────────────────────────────────┘
                        │
                        ▼
              .core/ (local state)
              Persistent across sessions

The key insight: Replaceables Core sits between Kiro and your project as an agentic middleware layer. It intercepts Model Context Protocol messages to inject intelligence — persistent memory retrieval, dynamic tool routing, semantic caching, neural learning signals, and context window optimization — without changing how you interact with Kiro. At session end, it automatically stores a structured digest of what happened (files modified, commands run, patterns searched) so the next session has full context. It's the runtime that turns ephemeral LLM tool-use into a compounding system that gets better the longer you use it.

Capabilities

🧠 Persistent Memory

Information survives across sessions. Store decisions, patterns, solutions, and context — then retrieve them by keyword search or semantic similarity. This is the agent memory layer that gives your AI coding assistant long-term recall.

• Session Digest (automatic) — every meaningful session stores a structured summary at shutdown: files modified, commands run, search patterns, and tool usage. No agent cooperation required.
• BM25 keyword search — find exactly what you stored
• Vector similarity search — find semantically related information via embeddings
• Knowledge graph — understand relationships between memories (PageRank ranking)
• Memory bridge — automatically imports your project files into searchable memory
• Smart retrieval — 5-phase RAG pipeline (expand → fuse → boost → diversify → interleave)
• Structured context eviction — dependency-graph-aware pruning preserves causal reasoning while aggressively freeing recoverable action history

🤖 Agent Coordination

Four specialized agents generated at init, each with focused capabilities:

| Agent | Role | Use When | |-------|------|----------| | Orchestrator | Coordinates multi-agent workflows | Complex tasks needing decomposition | | Coder | Writes and modifies code | Implementation work | | Tester | Writes and runs tests | Quality assurance | | Reviewer | Reviews code and provides feedback | Code review and auditing |

📋 Task Management

Track work with full lifecycle management:

task_create → task_assign → task_status (update) → task_list (view all)

Tasks have statuses, assignments, and integrate with the neural learning system — outcomes feed back into better future routing decisions.

🎯 Goal Planning (GOAP + DAG Orchestration)

For complex objectives, the Goal-Oriented Action Planning system:

1. Define a goal with success criteria
2. The planner decomposes it into ordered action steps (A* search)
3. Goal plans automatically identify parallelizable steps and execute them concurrently for 2-5x speedup
4. Track progress with drift detection
5. Cross-session horizons maintain long-term objectives

🔄 Autopilot

Autonomous execution loops for repetitive or multi-step work:

• Predict — determines optimal next action from current state
• Execute — performs the action
• Learn — records outcome for future improvement
• Repeat — continues until goal is met or intervention needed

🧬 Intelligence Pipeline

The system learns automatically from every task execution:

1. Retrieve — pulls relevant historical patterns
2. Judge — scores candidates for quality
3. Distill — extracts strategies and classifications
4. Consolidate — promotes high-confidence patterns into reusable skills

When patterns reach high confidence, they're automatically synthesized into Kiro skill files — your agents literally get smarter over time.

🔄 Self-Improving Harness

Replaceables Core analyzes its own performance metrics weekly and adjusts configuration to optimize for your project's usage patterns:

• Metric analysis — reads gate rejection rates, cache hit rates, compression ratios, budget utilization
• Conservative proposals — max 10% change per parameter, requires 100+ data points for statistical confidence
• Config versioning — full audit trail of all changes with instant rollback to any previous state
• Auto-rollback — if quality degrades after a change (>20% rejection increase or >15% cache hit drop), automatically reverts
• Circuit breaker — disables optimizer after 3 consecutive rollbacks until manual re-enable

⚡ Tool Attention (Dynamic Tool Gating)

The invisible optimization that solves the "Tools Tax" — where MCP tool schemas consume your model's context window:

• 197 tools available, but only ~12 loaded with full schemas per turn
• Semantic routing matches your intent to relevant tools
• Adaptive threshold learns per-domain from your usage patterns
• tool_discover escape hatch — any tool is always one call away
• Cache-friendly ordering — tool list sorted for provider-side prompt cache reuse (stable prefix across turns)
• Semantic response caching — identical/similar read-only calls return cached results (~30-70% fewer redundant executions)
• Result: ~80% reduction in per-turn context overhead

📦 Response Compression

Verbose tool outputs are automatically trimmed to prevent context window bloat:

• Strip embedding vectors, raw data, and metadata fields from JSON responses
• Trim long arrays to configurable limits with count indicators
• Hard character caps with truncation markers for very long outputs
• Error responses and short responses (<500 chars) are NEVER compressed
• Per-tool configuration with sensible defaults — zero setup required
• Result: 40-98% reduction in response token usage for verbose tools

🔒 Security

Built-in protection that runs automatically:

• 4-point guardrail layering validates input, tool arguments, tool responses, and final output
• Catches path traversal, SQL injection, PII leaks, secrets, and hallucination signals before they reach the client
• Input validation (command injection, path traversal, SQL injection)
• Prompt injection detection
• PII detection (emails, SSNs, credit cards, API keys)
• Security audit log
• Governance policy via .core/mcp-policy.json
• Guardrail config via .core/guardrails.json (per-tool overrides, action levels)

🔌 Plugin System

Extend Replaceables Core with custom tools:

core plugin install <npm-package>    # Install from npm
core plugin install ./my-plugin      # Install from local path
core plugin create my-feature        # Scaffold a new plugin

Plugins are ESM modules that register additional MCP tools. They're loaded, activated, and managed automatically.

📊 Observability

Full telemetry for understanding system behavior:

• Distributed tracing with span trees
• Counters, gauges, and histograms
• OTLP export support
• Per-tool duration tracking
• Live dashboard — HTTP server with /metrics (Prometheus), /health, /traces, and /events (SSE) for real-time monitoring during autonomous execution

🚀 Autonomous Execution

Replaceables Core doesn't just coordinate — it executes. The Execution Bridge connects coordination primitives to real agent sessions:

• Safety gates — cost limits ($1/session default), iteration caps, duration timeouts, and approval requirements
• Agent profiles — 4 specialized agents (coder, tester, reviewer, orchestrator) with role-appropriate tool access
• Neural feedback — every execution outcome feeds the learning system for continuous improvement
• Idempotent dispatch — same request ID → same result (no duplicate execution)

🏗️ Self-Assembling Workflows

Replaceables Core learns the optimal workflow for your codebase and assembles it automatically:

• Pattern analysis — extracts recurring successful agent sequences from episodic memory
• Template selection — matches task domain and complexity to learned workflow templates
• Auto-restructuring — inserts steps, reorders agents, and parallelizes work based on what historically succeeds
• Evolution tracking — measures template effectiveness over time for continuous improvement

🔬 Regression Fortress

Chaos testing and property-based validation ensuring Replaceables Core never breaks under stress:

• Property-based testing — random input generation with invariant checking across all tools
• Chaos injection — file corruption, process kill, disk full simulation
• Concurrency stress — parallel session safety with deadlock and race detection
• Mutation testing — measures test suite quality by injecting code mutations
• Recovery validation — graceful degradation and data integrity after failures

📈 Continuous Evaluation

Statistical proof that Replaceables Core improves productivity through automated A/B testing:

• Standardized task corpus — 20-50 tasks of varying complexity
• A/B runner — same tasks executed with and without Replaceables Core for fair comparison
• Confidence intervals — statistical significance testing with p-values
• Regression detection — new changes can't make Replaceables Core worse without alerting

⏪ Deterministic Replay

Every autonomous execution is recorded for post-hoc debugging:

• Time-travel — inspect state at any point in an execution timeline
• Diff comparison — identify divergence between successful and failed runs
• Observability export — convert recordings to OpenTelemetry, Jaeger, or Zipkin traces

🩺 Health Score

Self-awareness system monitoring Replaceables Core's own effectiveness:

• 6 dimensions — pattern quality, memory freshness, learning velocity, execution success, cost efficiency, guardrail coverage
• Composite 0-100 score — weighted metric with trend analysis
• Actionable recommendations — specific actions to improve each dimension
• Degradation alerts — early warning when health drops

🔒 Memory Integrity

Intelligent knowledge curation preventing memory pollution over months of use:

• Decay scoring — multi-factor staleness detection (recency, access, relevance)
• Conflict resolution — contradictory patterns identified and resolved
• Corruption detection — checksum verification with auto-repair
• Selective archival — stale knowledge moves to cold storage but remains searchable

👥 Cross-Project Learning

Team intelligence amplification through selective knowledge sharing:

• Privacy-controlled sharing — explicit opt-in, namespace isolation, anonymization
• Relevance filtering — only applicable knowledge transfers between projects
• Team skill library — shared skills with effectiveness tracking
• Aggregate analytics — team-wide health scores and transfer opportunities

🏢 Enterprise Compliance

Accountability framework for regulated environments:

• Immutable audit trail — SHA-256 chain integrity, tamper-evident logging
• Approval workflows — risk-based routing with multi-level approval chains
• RBAC — role-based permissions with comprehensive audit trails
• Compliance reporting — automated SOC2, ISO 27001, and GDPR reports
• Retention management — policy-driven data lifecycle with legal hold support

CLI Reference

Setup & Health

core init              # Generate .kiro/ structure + MCP config
core status            # Show system status (memory, agents, tasks)
core doctor            # Check installation health

Session Management

core session status        # Show context archive status
core session save          # Manually save session context
core session restore       # Restore archived context
core session full-save     # Save complete system state snapshot
core session full-restore  # Restore from snapshot
core session list          # List available snapshots
core session diff          # Compare two snapshots

Autopilot & Goals

core autopilot status     # Show autopilot state
core autopilot enable     # Enable autonomous execution
core autopilot disable    # Disable autopilot
core goal create          # Create a goal with success criteria
core goal status          # Show goal progress + drift + DAG parallelism
core goal list            # List all goals
core goal plan-dag        # View DAG structure with parallel groups and speedup

Architecture & Methodology

core adr create           # Create Architecture Decision Record
core adr list             # List ADRs with status filter
core sparc start          # Start a SPARC methodology session
core sparc status         # Show SPARC progress

Sync & Collaboration

core sync status          # Show multi-workspace sync status
core sync push            # Push patterns/skills to manifest
core sync pull            # Pull from paired workspaces
core sync discover        # Find available workspaces

Plugins & Workers

core plugin install <pkg> # Install a plugin
core plugin list          # List installed plugins
core plugin create <name> # Scaffold a new plugin
core worker status        # Show background worker status
core worker list          # List all workers with metrics

Observability

core workflow list        # List workflows
core trace list           # List recent traces
core metrics              # Show metrics summary
core dashboard start      # Start live observability dashboard (HTTP server)
core dashboard status     # Show dashboard server state
core dashboard stop       # Stop the dashboard server

Autonomous Execution

core execute run          # Execute a task via specified agent type
core execute status       # Check execution status
core execute config       # View/update safety configuration
core execute history      # List recent executions with outcomes

Evaluation & Testing

core evaluate run         # Run evaluation pipeline against task corpus
core evaluate status      # Show evaluation pipeline status and history
core replay list          # List recorded executions
core replay <id>          # Inspect a specific execution recording
core replay diff <a> <b>  # Compare two execution recordings
core health               # Show Replaceables Core health score (0-100) with dimension breakdown
core health recommend     # Get actionable improvement suggestions

Memory & Knowledge

core memory verify        # Run integrity checks on .core/ data
core memory decay         # Show knowledge decay analysis
core memory conflicts     # Detect and resolve contradictory patterns
core memory archive       # Archive stale knowledge entries

Team & Compliance

core team status          # Team-wide intelligence dashboard
core team sync            # Cross-project knowledge sharing
core team library         # Shared skill library management
core audit status         # Compliance and audit trail health
core audit verify         # Verify audit chain integrity
core audit report         # Generate compliance report (SOC2, ISO, GDPR)

Lifecycle Hooks (Automatic)

These run without any user intervention:

| Hook | When | What It Does | |------|------|--------------| | Session Start | Kiro opens | Restores archived context from previous sessions | | Memory Bridge | Kiro opens | Imports project memory files into searchable index | | Context Archive | Each message | Proactively archives conversation turns | | Session Digest | Kiro closes | Captures files modified, commands run, search patterns, and tool usage — stores a structured session summary in memory automatically | | Session End | Kiro closes | Saves session state for next time | | Autopilot Learn | After tasks | Records task outcome for learning pipeline |

Background Workers (Automatic)

These run on intervals without user intervention:

| Worker | Interval | Purpose | |--------|----------|---------| | Health | 5 min | Memory usage, disk space, file integrity | | Patterns | 15 min | Neural consolidation (decay, dedup, prune) | | Memory Optimize | 30 min | Rebuild vector index, compact memory | | Cache Cleanup | 60 min | Remove stale entries, trim logs |

Configuration

Replaceables Core works with zero configuration. For advanced tuning:

Tool Attention

Create .core/tool-attention.json:

{
  "enabled": true,
  "threshold": 0.25,
  "topK": 12,
  "coreTools": ["system_status", "system_health"]
}

• threshold — cosine similarity cutoff (lower = more tools promoted)
• topK — maximum tools with full schemas per turn
• coreTools — tools that are never gated out

Security Policy

Create .core/mcp-policy.json to configure rate limits, blocked patterns, and namespace restrictions.

Vector Search

Three embedding providers available for semantic memory retrieval:

| Provider | Setup | Quality | Speed | |----------|-------|---------|-------| | TF-IDF (default) | Zero config | Good | Fast | | Transformers.js | npm install @xenova/transformers | Better | Medium | | OpenAI | Set OPENAI_API_KEY | Best | Network-dependent |

Creating Plugins

Extend Replaceables Core with custom MCP tools:

import type { CorePlugin } from '@replaceables/core';

export const corePlugin: CorePlugin = {
  metadata: {
    name: 'core-plugin-my-feature',
    version: '1.0.0',
    description: 'My custom extension',
  },
  tools: [{
    name: 'my_custom_tool',
    description: 'Does something useful',
    inputSchema: { type: 'object', properties: { input: { type: 'string' } } },
    handler: async (args) => ({
      content: [{ type: 'text', text: JSON.stringify({ result: args.input }) }],
    }),
  }],
  async initialize(context) { /* setup logic */ },
  async shutdown() { /* cleanup logic */ },
};

Requirements

• Node.js ≥ 20.0.0
• Kiro (IDE or CLI)
• npm (comes with Node.js)

FAQ

Q: Does it automatically remember what I worked on? A: Yes. Every session that does meaningful work (3+ tool calls using 2+ different tools) automatically stores a Session Digest at shutdown. This captures which files were modified, which commands were run, and what was searched for — without requiring the agent to call memory_store. The next session can retrieve this context automatically. This is the guaranteed memory population mechanism.

Q: Does this send my code anywhere? A: No. Replaceables Core runs entirely locally. Memory, state, and learning data stay in .core/ on your machine. No network calls unless you explicitly configure OpenAI embeddings or federation.

Q: Will this slow down Kiro? A: The opposite — Tool Attention reduces the tokens sent per turn by ~80%, which means faster responses and lower cost. The MCP server adds negligible latency (<5ms for routing).

Q: What happens if I uninstall it? A: Delete .kiro/settings/mcp.json's Core entry and remove .core/. Kiro returns to normal. Your code is never modified by Replaceables Core.

Q: Does it work with existing .kiro/ configurations? A: Yes. core init merges non-destructively — it won't overwrite existing MCP configurations, only adds the Replaceables Core server entry.

Q: How much disk space does it use? A: Minimal. The .core/ directory typically stays under 10MB even with heavy usage. Background workers automatically clean stale data.

Q: Can I use it on multiple projects? A: Yes. Run core init in each project. Each gets its own independent .core/ memory and state. The sync feature optionally shares patterns between workspaces.

Q: Does it work with Kiro CLI or just the IDE? A: Both. Replaceables Core connects via the standard MCP protocol over stdio, which works identically whether you're using Kiro IDE or kiro-cli. The same agent memory, tool orchestration, and autonomous workflows are available in both environments.

Q: Does it cache tool responses? A: Yes. Read-only tools (search, list, status) with identical or semantically similar arguments return cached results within a session. Write operations (store, create, update) automatically invalidate the cache. This eliminates 30-70% of redundant tool executions without any risk of stale data. See docs/RESPONSE_CACHING.md for details.

Q: Can I control token costs per session? A: Yes — set per-session token budgets via budget_session_set. Replaceables Core automatically degrades gracefully (fewer promoted tools) as limits approach, and blocks at hard limits. Circuit breakers prevent runaway costs from failing tools that would otherwise retry endlessly.

Q: How do I see Replaceables Core's value? A: Run core costs or use the cost_dashboard MCP tool. Replaceables Core shows exactly how many tokens it saved per session, broken down by feature (tool attention, response caching, compression, cascade routing). Add --history to see daily trends over time.

Q: Does it compress tool responses? A: Yes. Verbose tool outputs (memory search results with embedding vectors, long trace lists, etc.) are automatically compressed before delivery to the client. The full response is still cached for future lookups. Configure per-tool compression via .core/response-compression.json or the compression_config MCP tool. See docs/RESPONSE_COMPRESSION.md for details.

Q: How does this compare to other AI agent memory tools? A: Replaceables Core is purpose-built for Kiro and provides an all-in-one agentic infrastructure layer: not just memory, but multi-agent orchestration, self-learning via neural pattern consolidation, autonomous execution loops, context window optimization, task decomposition with GOAP planning, and a plugin system — all integrated into a single MCP server with zero configuration. It's the difference between adding a memory plugin and installing an entire agent runtime.

Testing

# Run unit tests (3500+ tests)
npm test

# Run integration tests (live MCP transport validation)
npm run test:integration

# Quick health check (spawns server, calls critical tools)
core doctor --full

# Run performance benchmarks
npm run bench

The integration test suite spawns a real MCP server process and connects via the official @modelcontextprotocol/sdk client. Each test suite gets an isolated temp .core/ directory — no cross-contamination between tests. See docs/INTEGRATION_TESTING.md for architecture details and how to add new integration tests.

License

MIT