Richard Ketelsen's picture

Richard Ketelsen PRO

CRAFTFramework

AI & ML interests

CRAFT applies structured programming principles to AI conversations. Think recipes for your workflows.

Recent Activity

posted an update about 11 hours ago
# CRAFT Session Handoffs: Solving the Stateless AI Collaboration Problem AI desktop tools like Claude Cowork are increasingly capable for multi-session projects — but they're architecturally stateless. Each session starts with an empty context window, losing all prior decisions, file states, and project context. The human becomes a manual bridge between sessions. ## Approach: Structured Handoff Protocol CRAFT addresses this with a multi-format handoff protocol that captures complete session state in structured text files. At session end, a handoff recipe records accomplishments, decisions, file manifests, git state, active priorities, open questions, lessons learned, and persona configuration. At session start, an initialization recipe reads the latest handoff and restores full context. The system uses four purpose-built recipes: Session Initialization (CWK-001), Direct Handoff (CWK-002), Device-Switch Handoff (CWK-002a), and Mid-Session Checkpoint (CWK-003). A two-layer initialization architecture — static CLAUDE.md bootstrap plus dynamic recipe state — provides redundancy against stale components. A 4-layer propagation chain ensures persistent behavioral directives survive across sessions and framework updates: CLAUDE.md, project file, generator template, and enforcement recipe. ## Empirical Results The system was validated during CRAFT's own development: 71 consecutive handoffs (H001–H071) with zero data loss. The handoff protocol survived 5+ context compaction events, multiple application crashes, and a cross-device transfer. Each session relied on the previous session's handoff for complete context restoration. ## Key Design Decisions Handoff files are stored as structured plain text on the user's local machine — no cloud dependency, full data ownership. The handoff itself triggers an automatic git commit, providing version history of the project's session state over time. Free public beta: [github.com/CRAFTFramework/craft-framework]
posted an update 7 days ago
CRAFT Framework: Structured AI Session Management for Claude Cowork — Free Public Beta Overview CRAFT (Configurable Reusable AI Framework Technology) is a structured communication framework that provides persistent session continuity, version control integration, and systematic quality assurance for AI-assisted workflows running on Claude's Cowork desktop platform. Technical Architecture CRAFT uses a recipe-based system — 188 standardized workflow definitions across 12 cookbooks — to manage the full lifecycle of AI project sessions. Key subsystems: - **Session Handoff System (4 recipes):** Structured state serialization that captures project context, decision history, and persona calibration between sessions. Validated across 71 consecutive handoffs with zero information loss over 72 development sessions. - **Version Control Integration (4 recipes):** Event-driven git checkpoints triggered by workflow completion rather than time intervals. Maintains over 500 files across 9 projects in a unified monorepo. - **Quality Assurance Framework (6 recipes, 14-point plan):** Includes 4 verification gates — file pointability, read-vs-reconstructed detection, constraint conflict analysis, and untested assumption identification. Addresses the systematic overconfidence problem in LLM output. - **Multi-Persona Collaboration (5 recipes):** Separate AI personas for content generation, validation, and operations management. The Creator/Validator pattern enforces independent review. - **Cross-Project Transfer (4 recipes):** Knowledge packaging with provenance tracking, enabling verified intelligence sharing between project contexts. Scale The framework grew from ~60 pre-existing recipes to 188 (213% increase) during a 72-session adaptation project. Development produced 7 formal specifications, 64 documented lessons learned, and ~59,000 lines of recipe content.
posted an update 14 days ago
Quick observation from working with Claude Cowork on multi-session projects. **The constraint:** Cowork runs in a sandboxed VM that resets between sessions. No state persistence, no conversation carryover, no cross-session memory. Each session starts with zero context about prior work. ``` https://craftframework.ai/the-hidden-cost-of-session-amnesia-why-context-matters-more-than-you-think/ ``` Within a single session, context compaction occurs as conversations approach the token limit — the system summarizes earlier exchanges, trading detail for capacity. Decisions made early in a session degrade to single-sentence summaries as the conversation grows. **The cost:** For task-based work (summarize this, debug that), this is irrelevant. For cumulative work — projects that build over days or weeks — it creates significant overhead. Users spend meaningful time each session re-establishing context that the AI previously held. **Common workarounds observed:** - Manual context injection (copy-paste at session start) - Single mega-sessions (avoids reset, but context degrades) - External state documents (maintained alongside the AI) Each trades one form of overhead for another. **The architectural question:** Claude's chat interface (claude.ai) now has persistent memory — free for all users since March 2026. But the desktop environment still operates on a session-reset model. The gap between chat-based memory and desktop-based amnesia is growing. This seems like a general problem for desktop AI tools, not just Cowork. How are others approaching session continuity in local AI environments?
View all activity

Organizations

Blog-explorers's profile picture CRAFT Framework's profile picture