FocalPoint — AI Cognitive Operating System#

Your AI forgets everything between conversations. FocalPoint fixes that.

Not just memory — cognitive infrastructure. FocalPoint tracks your projects, prepares context before tasks, uses a Three-Province review system for quality decisions, and proactively alerts you about stuck work.

The Problem#

AI agents are stateless. Every conversation starts from zero — no memory of your projects, decisions, or progress. You waste time re-explaining context and manually tracking what's stuck.

Existing solutions only go halfway:

ToolWhat it doesWhat it doesn't doMem0 / ZepRemembers conversationsDoesn't track tasks or alert youLangGraph / CrewAIOrchestrates agentsNo persistent cognitive layerClaude / OpenAI memoryRemembers preferencesDoesn't manage work or deadlines

They remember what was said. FocalPoint manages what needs to be done.

What You Get#

• Structured memory — Goal > Project > Milestone > Task hierarchy with status lifecycle
• Workbench — One call prepares goal, knowledge, context, subtasks, and role prompt
• Proactive alerts — Heartbeat detects blocked, stale, and at-risk tasks automatically
• Knowledge documents — Attach design docs to nodes; child tasks inherit parent knowledge
• Role-based thinking — Strategy, Review, and Execution roles see filtered perspectives
• Three-Province review — Parallel review by two reviewers before execution; max 3 rejections then escalate
• Full-text search — FTS5 search across titles, narratives, and knowledge documents
• GitHub + Notion sync — Issues and pages auto-sync as FocalPoint nodes
• Zero dependencies — Runs 100% locally on SQLite. No vector DB, no Redis, no cloud.

Competitive Comparison#

CapabilityMem0ZepLettaCrewAIClaudeFocalPointPersistent memoryYesYesYesYesYesYesTask lifecycle management---Partial-YesDependency graph (DAG)-----YesProactive alerts-----YesKnowledge docs + inheritance----PartialYesRole-based context---Partial-YesDecision review workflow-----YesFull-text searchVectorVectorVector--FTS5MCP native----ProprietaryYesSelf-hosted, zero depsPartialPartialYesYes-Yes

No competitor combines structured task management + proactive alerts + knowledge inheritance + role-based context + review workflow in a single MCP-native package.

Setup#

1. Install#

bash

pip install focalpoint

2. Add MCP server#

yaml

# openclaw.yaml
mcp_servers:
  fpms:
    command: focalpoint

3. Restart OpenClaw#

That's it. 22 tools are now available.

How It Works#

Architecture: Brain-Spine Model#

text

Brain (LLM)              Spine (FocalPoint engine)
  |                         |
  | -- Tool Call -->        | Validate -> Write SQLite -> Narrative -> Audit
  |                         |
  | <-- Context ---         | Assemble L0/L1/L2 -> Trim -> Inject prompt

• Brain = LLM. Only reads context and issues Tool Calls.
• Spine = Deterministic engine. All logic here. LLM never touches storage directly.

Storage: Pure SQLite#

text

SQLite           <- Single source of truth
events.jsonl     <- Audit trail
narratives/*.md  <- Append-only logs
knowledge/{id}/  <- Design documents

No vector database. No Redis. No PostgreSQL. One SQLite file is everything.

Work Mode#

Workbench — prepare before you work#

text

You: "Work on the payment system task"
AI calls activate_workbench(node_id, role="execution")
-> Returns: goal, knowledge docs, context bundle, sorted subtasks,
   suggested next step, and execution role prompt
-> AI enters role, reads background, starts working

Three Roles#

RoleFocusSeesStrategy (Maker)Should we do this? Priority?Decisions + feedbackReview (Reviewer)Any risks? Historical lessons?Risk notes + progressExecution (Engineer)How to build it? Acceptance criteria?Technical details + progress

Same data, different thinking modes. The role prompt guides the AI's perspective.

Three-Province Review — quality decisions#

For major decisions (new features, architecture changes, tech choices):

text

Strategy produces requirements
    |
Review + Engineer review in parallel
|-- Review: checks risks, historical lessons -> approve/reject
|-- Engineer: evaluates feasibility -> approve/reject
    |
Both approve -> proceed to execution
Either rejects -> revise and resubmit
    |
> 3 rejections -> escalate to human

Knowledge Documents — persistent design context#

text

You: "Save this architecture doc to the project"
AI calls set_knowledge(project_id, "architecture", content)
-> Child tasks inherit parent knowledge automatically
-> AI reads project overview without you re-explaining

Types: overview | requirements | architecture | custom names

Log Categories#

text

append_log(node_id, content, category="decision")   # Decision records
append_log(node_id, content, category="feedback")    # User/market feedback
append_log(node_id, content, category="risk")        # Risks and lessons
append_log(node_id, content, category="technical")   # Technical details
append_log(node_id, content, category="progress")    # Progress updates
append_log(node_id, content, category="general")     # Default

Different roles see different categories. Strategy sees decisions + feedback. Execution sees technical + progress.

Use Cases#

Project tracking#

text

You: "Create a project for the product launch with 3 tasks"
(Next day)
You: "What's the launch status?"
AI:  "3 tasks: 1 done, 1 active, 1 blocked. The blocked task
      is waiting on design review — it's been 2 days."

Decision memory#

text

You: "We're going with Stripe for payments"
AI:  append_log(node_id, "Chose Stripe — better API, lower fees", category="decision")
(Two weeks later)
You: "Why did we pick Stripe?"
AI:  Searches decisions -> "You decided on March 15 — better API and lower fees."

Risk detection#

text

AI automatically runs heartbeat and finds:
  - Deploy task BLOCKED for 4 days
  - Docs update STALE — no activity for a week
  - Bug fix AT RISK — deadline is tomorrow

Full-text search#

text

You: "Find everything related to caching decisions"
AI:  search_nodes(query="caching decisions")
-> Finds nodes by title, narrative content, and knowledge docs

Available Tools (22)#

Write (11)#

ToolWhat it doescreate_nodeCreate a project/task/goal/milestoneupdate_statusChange status (inbox/active/waiting/done/dropped)update_fieldUpdate title, summary, deadline, etc.attach_node / detach_nodeMove tasks in hierarchyadd_dependency / remove_dependencyManage task dependenciesappend_logRecord decisions, progress, risks (with category)unarchiveRestore completed/dropped tasksset_persistentProtect tasks from auto-archiveset_knowledgeAttach knowledge documents to nodes

Read (5)#

ToolWhat it doesget_nodeGet full details of a work itemsearch_nodesFind tasks by filters or full-text searchget_knowledgeRead knowledge with parent inheritancedelete_knowledgeDelete a knowledge documentget_assembly_traceDebug context assembly

Cognitive (4)#

ToolWhat it doesbootstrapLoad memory context (call at conversation start)heartbeatScan for risks: blocked, stale, at-risk tasksactivate_workbenchPrepare working context with role + knowledgeget_context_bundleGet role-filtered, token-budgeted context

Review (1)#

ToolWhat it doessansei_reviewThree-Province parallel review

Runtime (1)#

ToolWhat it doesshift_focusSwitch AI attention to a specific task

Automatic Memory Rules#

Follow these rules in EVERY conversation:

1. Conversation start -> Call bootstrap to load memory
2. Before starting a task -> activate_workbench to prepare context
3. User makes a decision -> append_log with category="decision"
4. Risk identified -> append_log with category="risk"
5. Task progresses -> update_status
6. Design conclusions -> set_knowledge to persist for future sessions
7. Before conversation ends -> append_log key takeaways
8. Every ~10 min -> heartbeat to check for risks

Stats#

MetricValueTests665MCP Tools22External dependencies0 (pure SQLite)Cold start< 100msSupported LLMsAny (via MCP protocol)PlatformsClaude Desktop, OpenClaw, any MCP client

Requirements#

• Python 3.10+
• No external services — runs 100% locally on SQLite

Links#

• GitHub
• PyPI