v0.1.0 Alpha

Reach
Flow State

Return to your coding projects after weeks away without the cognitive overhead. Instantly retrieve your context and pick up right where you left off.

Powered byMem0 Logo

Three Commands.
No cognitive overhead.

flow start

Begin tracking a session. Flow automatically injects project context into your AI rules files.

flow stop

End the session. Flow collates logs and git diffs, summarizes changes with an LLM, redacts secrets, and stores them in memory.

flow wake

Get a situational briefing on where you left off. Adapts detail based on absence length.

Demo

See It In
Action.

(flow) ~/auth-service

flow start records the HEAD commit, writes a PID file, queries Mem0 for prior context, and injects a compressed briefing into your AI tool's rules (like .cursor/rules/flow.mdc) before you write a single prompt.

Privacy First

Stored Locally.
Stay Secure.

Your code never leaves your machine. Flow runs locally and stores distilled context using Mem0 + Qdrant vector memory. Local storage, zero telemetry.

state.jsonLocal Vector DB
{
  "project_name": "auth-service",
  "project_path": "/home/dev/auth-service",
  "project_id": "auth-service-a1b2c3d4",
  "started_at": "2025-11-05T10:00:00Z",
  "pid": 48210,
  "base_commit": "7f2d1a3..."
}
Proactive Injection

Zero-Shot
Recall.

On flow start, Flow queries your project memory and injects a surgical 300-token context block into your AI tool's rules.

  • CLAUDE.md for Claude Code
  • .cursor/rules/flow.mdc for Cursor
  • AGENTS.md for Codex

"Your agent arrives with full project technical context before you even send the first prompt."

CLAUDE.md
**Current State:**

Refactoring auth middleware to support JWT rotation. Middleware logic in `/lib/auth.ts` is partially updated.

**Decisions:**

Switched from Redis to local cache for session IDs to reduce latency. Rejected DB-level session tracking.

**Dead Ends:**

Do not use `auth-v1` patterns; they are deprecated and will break the current migration.

NEXT:Complete the test suite in /tests/auth.test.ts
<!-- flow:start --> | 284 tokens | <!-- flow:end -->
Memory vs. Scanning

Why Not Just
Ask Your AI?

“Can’t I just ask Claude Code to look at my codebase and tell me where I left off?” You can. But what’s in your code is not the same as what you were doing.

Codebase scan

Dead ends vanish from code

If you tried WebSockets and switched to SSE, the codebase only shows SSE. Your next AI session will suggest WebSockets again. Flow remembers what failed and why.

Flow + Mem0

Flow tracks decisions, not just code

Code is the output of decisions. Flow stores the decisions themselves — why you chose Qdrant over Pinecone, why the auth flow is a workaround, what’s still unresolved.

Codebase scan

AI tools are stateless

Claude Code, Cursor, and Codex start every session with zero context about prior sessions. They can read files but can’t know what you decided yesterday.

Flow + Mem0

Flow injects context proactively

Before you send your first prompt, Flow has already queried your memory and injected what’s in progress, what failed, and what comes next into your agent’s rules file.

Your codebase tells an AI agent what your code does. Flow tells it what you were doing, what you decided, what didn’t work, and what to do next.

Works with your stack

No extra plugins required.

Claude Code
Supported
Cursor
Supported
Codex
Supported
Git
Supported