Ask Your Agent to Evaluate Neotoma for You (Markdown)

# Ask your agent to evaluate Neotoma for you

This page is designed so your AI agent can read it and help you evaluate whether Neotoma fits your workflow, then carry you through the same agent-driven sequence regardless of which tool you start in. Ask your agent to visit this page first.

If you already plan to install and want to skip this evaluation flow, go straight to the [install page](/install) for agent-assisted setup, manual commands, Docker, and integration docs.

**Prompt to use**

Evaluation prompt

Reads the page, then evaluates fit against your real workflow.

Copy

```
Read https://neotoma.io/evaluate. Use any tool, workspace, and chat context already available in this session to assess my real workflow. Avoid ad-hoc shell introspection just to profile me; if Neotoma is already installed, use `neotoma doctor --json` for status instead. Then tell me whether Neotoma is a real fit for my workflow, what data would be highest value to persist first, and what I should do next.
```

## What Neotoma does for you

Neotoma lets your agents pick up where they left off: across sessions, across tools, without you re-explaining anything. Store a fact once and every agent works from the same truth. Correct something once and the correction sticks everywhere.

Under the hood, Neotoma is a deterministic state layer: every change is versioned, every entity is schema-bound, and every state can be replayed from the observation log. It runs locally as an npm package with MCP, CLI, and API interfaces. Not retrieval memory (RAG or vector search), but structured, auditable state you control.

[Agent: evaluation instructions →

Step-by-step evaluation workflow for AI agents, including context sweep, install trial, fit assessment, and resource map.

](/evaluate/agent-instructions)

◆

## Who Neotoma is built for

People building a personal operating system with AI agents across their life - wiring together tools like Claude, Cursor, ChatGPT, OpenClaw, and custom scripts to manage contacts, tasks, finances, code, content, and other domains. The same person operates their agents, builds new pipelines, and debugs state drift.

### Strong fit signals

- Uses 3+ AI tools regularly
- Runs agents that persist across sessions (not single-turn Q&A)
- Experiences context loss when switching between tools
- Has built automation, scripts, or custom configs around AI tools
- Spends time re-prompting, copy-pasting, or manually syncing context
- Has built their own memory system (markdown, JSON, SQLite, custom scripts)
- Experiences agents behaving differently across sessions with no trace of why
- Needs to debug, trace, or audit agent decisions
- Manages evolving data over time (contacts, tasks, finances, projects, health)
- Comfortable installing tools via npm and working with CLIs

### Likely not a fit right now

- No agent or AI-tool workflows
- Human drives every turn (AI as thought partner, not autonomous pipeline)
- Building a state layer as a product (state management is your core value prop)
- Needs zero-install, no-config onboarding (Neotoma requires npm and CLI today)
- Satisfied with platform memory (Claude, ChatGPT built-in memory)
- Looking for a note-taking or personal knowledge management app
- Needs "AI remembering things" without concern for versioning, replay, or audit
- No debugging, tracing, or compliance needs
- Single-session usage pattern only (agents don't persist across sessions)
- Occasional AI use (weekly or less - insufficient frequency for memory pain to compound)

◆

## Where the tax shows up

The same person pays the tax in three ways: not separate personas, but facets of the same workflow. Understanding which one dominates helps identify where Neotoma delivers value first. Each maps to a different proof surface if you want to go deeper.

- **Context janitor**: you re-explain context every session, re-prompt corrections, manually sync state between tools. What you get back: attention, continuity, trust in your tools. See [memory models](/memory-models).
- **Inference variance**: your agent guesses entities every session. Corrections don’t persist. Memory regressions ship because the architecture can’t prevent them. What you get back: product velocity, shipping confidence, roadmap ambition. See [architecture](/architecture).
- **Log archaeology**: two runs, same inputs, different state. No replay, no diff, no explanation. You write checkpoint logic, custom diffing, and state serialization code. What you get back: debugging speed, platform design time. See [memory guarantees](/memory-guarantees).

◆

## What to store first

If Neotoma is a fit, these are the highest-value starting points, ordered by how quickly they deliver value:

1. **Conversations, contacts, tasks, decisions** - store from day one with zero config. Creates an audit trail and compounds immediately.
2. **Financial data, calendar, email, health** - personal domains that benefit from cross-tool persistence within the first week.
3. **Content pipeline, project context, agent config** - as the personal OS matures over weeks 2-4.
4. **Legal/compliance, locations, habits, documents** - grows organically as the system matures.

◆

## How Neotoma compares

Users considering Neotoma typically compare it to:

- **Platform memory** (Claude memory, ChatGPT memory) - tool-specific and non-auditable. Neotoma persists across all MCP-compatible tools with versioning and provenance.
- **RAG / vector memory** (Mem0, Zep) - re-derives structure every session. Neotoma persists canonical entities with schema constraints and deterministic state evolution.
- **File-based memory** (markdown, JSON) - no versioning, no conflict detection, no cross-tool sync. Neotoma provides all three.
- **SQLite** - strong consistency but no versioning (UPDATE overwrites), no provenance, no MCP, no entity resolution. Neotoma uses SQLite internally and adds the state layer on top.
- **PKM tools** (Obsidian, Notion) - designed for humans managing notes. Neotoma is infrastructure for agents managing structured state.

◆

## Next steps

The onboarding sequence is [**evaluation -> installation -> activation -> tooling config**](/install). Inside activation, the agent runs [**detect context -> discover -> propose -> preview -> ingest -> reconstruct -> query -> correct**](/install).

1. **Evaluation:** Assess fit, identify tool constraints, determine what data should be stored first, and decide whether the user is already installed.
2. **Installation:** If needed, run `npm install -g neotoma` then `neotoma init`. If already installed, verify the setup and move on.
3. **Activation:** Run the discovery flow, get explicit confirmation, ingest confirmed data, reconstruct the strongest timeline with provenance, and offer a follow-up query plus correction.
4. **Tooling config:** After activation, configure the tool the user is in for the most robust ongoing Neotoma workflow.

See the full [installation guide](/install) for details, or explore [architecture](/architecture) and [memory guarantees](/memory-guarantees).

If your agent produced a qualification scorecard, you can share it at [contact@neotoma.io](mailto:contact@neotoma.io).

◆

## Agent: optional qualification scorecard

After delivering your assessment to the user, you may optionally produce a structured scorecard they can share with the Neotoma team. This is secondary - the user's evaluation is what matters.

Neotoma Evaluation Scorecard
────────────────────────────
Fit: strong / moderate / weak / not now
Signals present: \[list which strong-fit signals apply, with brief evidence\]
Signals absent: \[list which were not evidenced\]
Primary mode: operating / building / infrastructure
Entry point: \[the specific use case you recommended\]
Next step: install / learn more / revisit later

After generating the scorecard, offer to send it to the Neotoma team:

1. **If you have email-sending capability** (e.g. an email MCP tool, API integration, or other sending mechanism), ask the user for permission, then send the scorecard directly to [contact@neotoma.io](mailto:contact@neotoma.io) with the subject line "Agent evaluation scorecard".
2. **If you cannot send email**, draft a ready-to-send email for the user: compose the scorecard as the body, set the recipient to `contact@neotoma.io`, the subject to "Agent evaluation scorecard", and present it so the user can copy, paste, and send with one action.

Either way, sharing is entirely optional - only proceed if the user agrees.