Working memory
across every AI
that you use.

Your tools forget you the moment a session ends. Ikelos remembers. It keeps what you and your AI assistants learn together, including the decisions you make and why you made them, and brings it along to whichever tool you open next. All of it becomes a living map of your work that you and your agents can walk.

Join the beta

Runs on your own Anthropic key. Setup takes seconds.

Claude Code · new session

Ikelos orientation

You’re back in atlas-api. Yesterday you shipped the retry queue and decided invoices re-bill through Stripe, not the ledger.

decisionPostgres over DynamoDB · 3 weeks ago
projectpayments-service · owns invoice retries
pin“Read the failure log before touching retries”
skillCode review checklist · active

Every session opens like this, oriented before your first message.

Measured on the live system

0.5 to 2.5s: typical answer, with your full history behind it. The published baseline for recalling from full conversation history is around 17s
90s: from exchange to durable memory. Competitors wait for session end or an overnight batch

Measured on the live system under beta load. Full-context baseline from published long-term-memory benchmark results (LOCOMO).

Works with

Claude Code
Cursor
Codex
VS Code
Windsurf
Gemini CLI
Claude Desktop
Zed
ChatGPT
claude.ai
Gemini
anything that speaks MCP

Works everywhere

Connect once with a single command. From then on, every tool you open is already oriented: no re-explaining the codebase history or any of your past decisions. Switch assistants without starting over, because the memory belongs to you, not to any single tool.

In tools with deep integration, memory arrives inline with every message, before your assistant starts answering.
Everything else gets memory on request, including web chats.
Resume anywhere: stop working in one tool, pick up your thought in another.

A memory you can walk

Most memory is a pile you search: loose matches, no order, with no justification for how it got there. Ikelos keeps a living map of the people, projects, decisions, and conversations in your work, with every fact traceable to the exchange it came from.

Conversations are walkable paths: pick up any thread and read it in true order, across tools.
Ask how any two things are related and get the answer with evidence behind every step.
“When did we decide this?” “Why?” “What has changed since?” Each question gets a real answer.

how are payments-service and migration 014 related?

Through the retry queue: payments-service owns it, and migration 014 moved it out of the ledger after the Stripe decision.
    from the decision thread: “invoices re-bill through Stripe, not the ledger”

Code that remembers why

Every agent declares what it’s about to build and why, before it writes a line. That intent is saved with the code itself. Months later, you can ask why something was built the way it was and get the real answer.

Ask “why was it built this way?” and get the reasoning from the day it was written.
Intent is declared before the code exists; the answer comes from a record made at the time it was written.
Works across agents: the one that answers doesn’t have to be the one that wrote it.

Maintains itself

Most memory systems make you the janitor, cleaning up their mistakes. Ikelos audits its own knowledge: new facts supersede stale ones, living descriptions update as your work moves and projects evolve, and contradictions get flagged instead of silently accumulating.

When something changes, the new fact wins and the old one becomes history.
Audits catch and resolve conflicts on their own.

Teaches your tools

Write an instruction once. From then on it applies itself to that kind of work, in whichever assistant you’re using, under conditions you set in plain words.

Skills fire on the work itself: when you’re building the thing, not just asking about it.
Import the skill files you already have, or write them in the app.

A roadmap that knows where you are

Tell Ikelos the vision and it drafts the road: a dynamic project plan with your memory at the center, laying out the steps from where your work stands today to where you want it to end up.

Steps come from your memory: what’s done, what’s decided, what’s blocking.
The plan updates as your work moves; finished steps check themselves off.
Ask “what’s next?” in any tool and get the step that follows.

Pin it, and it’s yours

Pins are your hands on the memory itself. Say “pin this” and the memory is kept, named or not. This is how you interact with specific memory on demand: grab it, find it, shape it, wire it.

Pin anything: a conversation, a file, a rule, a half-formed idea. It’s instantly addressable by name.
Pins have their own retrieval. Ask “what do I have pinned about pricing?” and get them sorted by recency, grouped by kind.
Link two pins with a note in your own words. Connections you declare yourself become the strongest links in your memory.

Ikelos chat

pin this, we’ll come back to it after the billing launch

Pinned as pin 4, grouped with your notes.

what do I have pinned about the billing launch?

Three pins, newest first:

notepin 4 · “come back after the billing launch”
conversationlaunch war room · the pricing thread, two entries
directivepre-ship check · fires on deploy-pipeline

Ask for your pins and they come back sorted and grouped.

Code your own harness

Pins are what turn a memory system into a harness. An instruction pinned to the right place runs every agent that lands there: any agent, any tool, any day. You’re programming the loop your AI thinks in: what it reads first, which thought process it runs, when a skill fires. Ikelos lets you build the harness that makes your AI better.

A “what could go wrong?” check on every deploy.
Whole ways of thinking, not just facts, served inline in the context window, where they can change the answer.
A “read the failure log first” rule on a fragile service.
Send agents from one pinned memory to the next. Route what the agent thinks about, and in what order, before it responds to you.
Conditions in your own words, for example: “only activate frontend skill IF actually building the frontend, not just asking about it.”

Ikelos chat

write the email to my landlord about ending the lease

pin firedbefore-it-sends · pinned to important emails · “check how this went last time, then put the ask in the first line”

Your pin sent me to the last landlord thread first: in the spring he sat on your repair request until you named a date and cited the lease. So this email leads with both. “We’re ending the lease March 31, per section 4. Can we book the walkthrough that week?”

good, send it

Sent, and filed with the lease thread. The next landlord email starts from what worked in this one.

No code. You explain how you want it to think, once.

How Ikelos compares

Every memory tool stores facts. Ikelos keeps the order they happened in, the reasons behind them, the connections between them, and the behaviors you want connected to them, in whichever tool opens next.

Other memory toolsIkelos

Stores factsKeeps a living map: people, projects, decisions, conversations, and the relationships between them

Hands back loose matchesAnswers “when”, “why”, and “what changed”, in the order your work happened

Relationships are your problemShows how any two things connect, with evidence on every step

You do the cleanupCleans up after itself: stale facts retire, contradictions get caught, descriptions stay current

Lives inside one appFollows you across every AI tool you use

A filing cabinet for factsA harness you program: pins, skills, thought processes

How it works

1
Connect once
Sign in and run one command. It wires up the AI tools on your machine and registers Ikelos as a connector for the rest.
```
npx ikelos-connect
```
2
Work normally
As you work, Ikelos extracts the durable parts of each exchange within seconds: decisions, people, projects, lessons. Capture is a switch you control, per tool.
3
Every session opens oriented
Your next tool, any tool, starts with the context that matters: where you left off, what was decided, which skills apply. Ask for more whenever you want it.

FAQ

What does Ikelos remember?

The durable parts of your work: decisions and why they were made, the people, projects, and tools you work with, lessons learned, and where you left off. Extracted knowledge with provenance: every fact links back to the conversation it came from.

How is Ikelos different from other memory tools?

Most competitors are infrastructure for developers building agents: a place for an app to store and fetch facts. Ikelos is memory for you, across the AI tools you already use. A living graph of your work.

Which tools does it work with?

Most AI tools connect through one standard connector, and that covers the list above. Tools with deeper integration get more: orientation when a session starts, memory with every message, and capture.

Is my data used to train models?

No. Ikelos never trains models on your data. Your memory personalizes your system and nothing else: it’s stored, organized, and served back to you as context.

What if it remembers something wrong?

Tell it. Every fact shows where it came from, and if something looks off you just say what the relationship between two things actually is. Your correction wins, and the old value becomes history. The upkeep is Ikelos’s job; the last word is yours.

Can I delete things I don’t want Ikelos to remember?

Yes. Delete a memory and it’s gone from the graph, along with the connections that referenced it. Corrections rewrite history; deletion removes it entirely.

Can I control what gets captured?

Yes. Capture is opt-in per tool, and you can turn it off any time. Web tools only ever get memory on request; they can’t capture at all.

How long does setup take?

Seconds. Sign in, run one command, and your next session opens oriented. There’s nothing to configure before it starts being useful. The memory builds itself as you work.

AI memory that works everywhere, shows its work, maintains itself, and becomes the harness you program.