engram-plan

Name: engram-plan
Availability: InStock
Author: PhaniJ

Sequence Rust core, TypeScript bindings, and storage adapters for agentic memory roadmaps.

Updated Jun 29, 2026

Search Tags:#typescript #architecture #rust #software-design #engram #agentic-memory

Ready to run

npx skills add https://github.com/phanijapps/engram --skill engram-plan

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: engram-plan
Source: https://github.com/phanijapps/engram/tree/main/.claude/skills/engram-plan
Command: npx skills add https://github.com/phanijapps/engram --skill engram-plan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill addresses the complexity of designing and implementing agentic memory layers by providing a structured, contract-first planning framework that ensures modularity and technical alignment.

Core Features & Use Cases

Implementation Sequencing: Guides the logical build order of Rust-based memory cores, TypeScript bindings, and storage adapters.
Contract-Backed Planning: Enforces the use of domain models and ports-and-adapters architecture to prevent tight coupling.
Use Case: Use this skill when you need to define the roadmap for a new memory-enabled agent, ensuring that the Rust domain crate, storage adapters, and TypeScript SDK are developed in a testable, vertical-slice-oriented manner.

Quick Start

Use the engram-plan skill to generate a development roadmap for the new SQL storage adapter based on the existing crate map.

Frequently Asked Questions about engram-plan

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I architect an agentic memory system for durable agent context?▼

Architecting an agentic memory system requires structuring an implementation roadmap that sequences Rust core components, TypeScript bindings, and storage adapters using domain-driven design principles and ports-and-adapters patterns for modularity.

What is the best way to sequence Rust and TypeScript bindings for agent memory?▼

Sequencing Rust and TypeScript bindings is best achieved through vertical slice definition, mapping crate dependencies to logically build the Rust memory core and TypeScript SDK in a testable, contract-backed manner.

How does ports-and-adapters architecture apply to storage adapters in Rust?▼

Ports-and-adapters architecture applies to storage adapters by enforcing contract-backed domain models, preventing tight coupling between the Rust domain crate and its storage implementations while maintaining modularity.

Do I need domain-driven design to build a memory-enabled agent roadmap?▼

Domain-driven design is required to build a memory-enabled agent roadmap, ensuring the Rust domain crate, storage adapters, and TypeScript SDK are developed in a testable, vertical-slice-oriented manner.

Can I use this approach to plan a new SQL storage adapter for an existing crate map?▼

You can use this contract-first planning approach to generate a development roadmap for a new SQL storage adapter based on an existing crate map, ensuring testable vertical slices and modular integration.