No. Flat keys, string values, five operations. It is closer to a sticky note than a schema. If you find yourself wanting a WHERE clause you have outgrown it, and that is fine.

What happens when I hit 25 keys?

A write that would create a 26th fails with a message the agent can read and act on. Deleting a key, or letting one expire, frees the slot immediately.

Can two agents share a keyspace?

Yes, as long as they authenticate as the same account. Every connector you approve reads and writes the same keys, which is usually the point — a scheduled task and a chat session need to agree on something.

What if my value is bigger than 2KB?

The write is rejected with the size and the limit, so the agent can decide what to trim. A URL pointing at the big thing usually fits.

Does it work outside Claude?

Anything that speaks remote MCP. Claude, Claude Desktop, Claude Code and Cowork are what we test against, but it is standard MCP over HTTP with OAuth, so ChatGPT connectors and Cursor connect the same way.

Can I stop an agent mid-flight?

Set a control — a typed setting you write in the dashboard that your agent may read and cannot change. Flip a boolean named paused and the next run reads it and stops. Writes to the control: namespace are refused, so it cannot clear its own stop flag. Junkt cannot kill a process, though: a control is somewhere your agent will reliably look, which works because you told it to look.

Can I see what my agent has been doing?

The dashboard lists every write, increment and delete, with the key, the time, and whether it came from MCP or the web UI. Changes you make to your controls are logged the same way.

Every connector shows in your dashboard with the date you approved it. Revoke one and its token stops working on the next call.

Is the free tier a trial?

No. 25 keys, free, indefinitely. A paid tier for a larger cap will come later, and nothing you set up now stops working when it does.

Durable memory for AI agents, over MCP

The missing state for your AI tasks

Junkt is a hosted key/value store your agents reach over MCP. Give them durable memory between runs — a timestamp, a flag, a counter — with no database, no setup, and no glue code.

Start storing state See how it works

Free to start · Live in under 10 minutes · No credit card.

agent · junkt mcp

# Did the daily digest already run today?
agent → get_value("cowork:daily-digest:last_run")
junkt ← { exists: false }

# No record. Run the task, then mark it done.
agent → set_value("cowork:daily-digest:last_run", "ok")
junkt ← { created: true, updated_at: "2026-05-31T09:00:00Z" }

Works with Claude, Claude Cowork, Claude Code, Claude Desktop, and any MCP-compatible client. Connect one in a minute.

Tiny on purpose

Somewhere to stash a value, without standing up a database

Five tools, flat keys, string values. The surface stays small so your agent can use it the moment it hits the “I just need to remember this” wall. One more lets you set what it may read but not change. Four more hand it a clock and a source of randomness, because it has neither.

MCP-native: The remote MCP server is the product. Your agent calls list_keys, get_value, set_value, increment, and delete_key directly.
Zero infrastructure: No Redis, no Postgres, no schema for three keys. Sign up, add the connector, and your agent has durable state.
Counters that don’t race: increment is atomic. Two runs firing in the same second both count, instead of one quietly overwriting the other. Pass a negative amount to go the other way.
Keys that clean up after themselves: Set a ttl in seconds and the key disappears when it elapses. Good for cooldowns, rate-limit windows, and “did this run in the last hour” checks. Expired keys stop counting against your 25 straight away.
Controls it cannot switch off: Set a flag, a mode or a limit in your dashboard and your agent reads it with list_controls. Writes to the control: namespace are refused, so it cannot clear the one that stops it. Pausing a running agent.
See what your agent did: Every write, increment and delete is recorded with the key, the time, and whether it came from MCP or the dashboard. Handing something persistent memory is easier when you can check its work.
Private by account: Every key is scoped to your account and never visible to anyone else. Tokens are issued over OAuth and revocable any time.
Namespace by convention: Flat keys up to 128 characters. Group them however you like — cowork:digest:last_run — then filter by prefix.
A clock and a dice roll: The time tool gives your agent the real clock in any timezone, including whether a stored timestamp was today. The random tools give it UUIDs, tokens and weighted picks. Left to itself it guesses the date, and reaches for the same few favourite numbers.
Right-sized values: Strings up to 2KB — a flag, a counter, a small JSON blob. This is state, not storage, and it stays fast because of it.

From signup to first tool call

Three steps, under ten minutes

1
Create your account

Sign up with an email and password, then confirm it in one click.
2
Add the connector

Paste your MCP URL into Claude. It registers itself and walks you through a quick OAuth approval — no client IDs to copy.
3
Read and write state

Your agent calls the tools straight away. The first one works on the first try.

The originating use case

“Did this scheduled task already run today?”

A scheduled agent wakes up and needs to know whether it already did its job. Without somewhere to remember, it either runs twice or never. Junkt gives it a single key to check — and an updated_at to reason about.

Give your agent a memory

junkt ← list_keys(prefix: "cowork:")
{
  total: 3,
  keys: [
    { key: "cowork:daily-digest:last_run",
      updated_at: "2026-05-31T09:00:00Z",
      size: 2 },
    { key: "cowork:weekly-report:last_run", ... },
    { key: "cowork:inbox:cursor", ... }
  ]
}

Scope

Things Junkt is not

Not a database: No queries, no relations, nothing resembling a schema. If you find yourself wanting a WHERE clause you have outgrown it, and that is fine.
Not a vector store: Embeddings and knowledge graphs are for recalling what was said. Junkt is for remembering that something happened.
Not storage: Values stop at 2KB on purpose. Anything larger belongs in a document store, and Junkt will say so rather than swallowing it.

Start free

Everything you need to give your agents memory. No credit card to begin.

Free

$0 / forever

For prototyping agents and remembering a handful of values.

Up to 25 keys per account

Values up to 2KB each

10 controls, on their own allowance

All ten MCP tools, counters and TTL included

OAuth tokens, revocable from your dashboard

Create your free account

Outgrown 25 keys? Tell us — a larger tier is coming.

Questions people actually ask

Still stuck? The docs go deeper, and support reaches a human.

Is this a database?: No. Flat keys, string values, five operations. It is closer to a sticky note than a schema. If you find yourself wanting a WHERE clause you have outgrown it, and that is fine.
What happens when I hit 25 keys?: A write that would create a 26th fails with a message the agent can read and act on. Deleting a key, or letting one expire, frees the slot immediately.
Can two agents share a keyspace?: Yes, as long as they authenticate as the same account. Every connector you approve reads and writes the same keys, which is usually the point — a scheduled task and a chat session need to agree on something.
What if my value is bigger than 2KB?: The write is rejected with the size and the limit, so the agent can decide what to trim. A URL pointing at the big thing usually fits.
Does it work outside Claude?: Anything that speaks remote MCP. Claude, Claude Desktop, Claude Code and Cowork are what we test against, but it is standard MCP over HTTP with OAuth, so ChatGPT connectors and Cursor connect the same way.
Can I stop an agent mid-flight?: Set a control — a typed setting you write in the dashboard that your agent may read and cannot change. Flip a boolean named paused and the next run reads it and stops. Writes to the control: namespace are refused, so it cannot clear its own stop flag. Junkt cannot kill a process, though: a control is somewhere your agent will reliably look, which works because you told it to look.
Can I see what my agent has been doing?: The dashboard lists every write, increment and delete, with the key, the time, and whether it came from MCP or the web UI. Changes you make to your controls are logged the same way.
Can I revoke access?: Every connector shows in your dashboard with the date you approved it. Revoke one and its token stops working on the next call.
Is the free tier a trial?: No. 25 keys, free, indefinitely. A paid tier for a larger cap will come later, and nothing you set up now stops working when it does.

Give your AI tasks a memory

Durable state for your agents in a few minutes. Start free, no credit card.

Start storing state

The missing state for your AI tasks

Somewhere to stash a value, without standing up a database

Three steps, under ten minutes

Create your account

Add the connector

Read and write state