Three models, one lineage.세 개의 모델, 하나의 계보.

WOS models are named for how people have kept knowledge through history - Tablet, Scroll, Codex. Stone, scroll, bound book: each one does more for your agent than the last.WOS 모델은 사람이 지식을 지녀 온 방식에서 이름을 땁니다 - Tablet, Scroll, Codex. 돌판, 두루마리, 제본된 책. 뒤로 갈수록 엔진이 에이전트를 위해 해내는 일이 늘어납니다.

Tablet 1's full benchmark report is on the benchmark page.Tablet 1의 전체 벤치마크 리포트는 벤치마크 페이지에 있습니다.

Pay us $2. Save many times that on your LLM.우리에게 $2, LLM에선 그 몇 배를 아낍니다.

WOS feeds your LLM ~1,200 tokens per query - a bounded, relevant slice - instead of stuffing the full history into every prompt. The gap is enormous, and it grows with your history.WOS는 매 프롬프트에 전체 히스토리를 욱여넣는 대신, 쿼리당 ~1,200개의 관련 토큰만 LLM에 전달합니다. 그 격차는 막대하고, 히스토리가 커질수록 더 벌어집니다.

Where the savings come from절감이 나오는 곳

• Without WOS you stuff the whole history into each prompt - 100K tokens × $2.50/1M = $0.25 per query, at GPT-4o input rates (about 2× that on Opus-tier models).WOS 없이는 매 프롬프트에 전체 히스토리를 넣습니다 - 100K 토큰 × $2.50/1M = $0.25, 매 쿼리마다 (GPT-4o 입력 단가 기준, Opus급 모델은 약 2배).
• With WOS you ingest once ($2/1M), then each query is a tiny retrieve ($3/1M × 1,200) plus your LLM on just ~1,200 tokens.WOS는 한 번만 적재($2/1M)하고, 이후 각 쿼리는 작은 검색($3/1M × 1,200)과 ~1,200 토큰에 대한 LLM 호출뿐입니다.
• The fewer tokens your LLM reads, the less you pay - and WOS keeps that number flat as memory grows.LLM이 읽는 토큰이 적을수록 비용이 줄고, WOS는 기억이 커져도 그 수치를 일정하게 유지합니다.

Every language, the same accuracy.모든 언어, 같은 정확도.

Retrieval is pure semantic - embeddings only, zero keyword or BM25 matching. So recall quality is identical whether your users write in 日本語, 中文, Español, or English.검색은 순수 의미 기반입니다 - 임베딩만 쓰고 키워드나 BM25 매칭은 전혀 없습니다. 그래서 사용자가 日本語, 中文, Español, English 무엇으로 적어도 검색 품질이 동일합니다.

Lexical matching like BM25 is tuned to the shape of a particular language - morphology, spacing, script. In a multilingual store that means retrieval quality varies by language. WOS uses no lexical matching at all, so every language goes through the same path.BM25 같은 어휘 매칭은 특정 언어의 형태 - 형태소, 띄어쓰기, 문자 체계 - 에 맞춰 동작합니다. 여러 언어를 섞어 쓰는 저장소에서는 그만큼 언어별로 검색 품질이 달라진다는 뜻입니다. WOS는 어휘 매칭을 아예 사용하지 않아, 모든 언어가 같은 경로를 지납니다.

One store, three languages at once한 저장소에 세 언어를 동시에

You don't pick a language per store - mix them freely. Below, one user's memory holds Japanese, English, and Spanish at the same time, and every question finds the right memory regardless of language. This is a real exchange against the live API:저장소마다 언어를 정할 필요가 없습니다 - 자유롭게 섞으세요. 아래는 한 사용자의 기억에 일본어·영어·스페인어가 동시에 들어있고, 어떤 언어로 묻든 맞는 기억을 찾아오는 모습입니다. 라이브 API에서 실제로 주고받은 내용입니다:

# one user, three languages stored together
mem.add("彼女はコーヒーより紅茶が好き", user_id="alice")                      # Japanese
mem.add("she works at a design studio in Brooklyn", user_id="alice")       # English
mem.add("A ella le encanta hacer senderismo los sábados", user_id="alice")  # Spanish

"¿Qué bebe ella?"               -> 彼女はコーヒーより紅茶が好き
"what does she do on weekends?" -> A ella le encanta hacer senderismo los sábados
"彼女の仕事は?"                  -> she works at a design studio in Brooklyn

No translation step, no language detection, no per-language config. Memories and questions are placed by meaning, not by language - if the meaning matches, the language doesn't matter.번역 단계도, 언어 감지도, 언어별 설정도 없습니다. 기억과 질문은 언어가 아니라 의미로 배치됩니다 - 맥락과 의미만 같으면 언어가 달라도 찾아냅니다.

Why we banned keywords on purpose키워드를 일부러 금지한 이유

Lexical scoring such as BM25 strengthens retrieval for some languages more than others, which gets in the way when one store holds many languages. So we removed it from the engine entirely and enforce that rule in code review: with any lexical scoring in the path, recall quality would differ by language.BM25 같은 어휘 점수는 특정 언어를 더 강화하는 성질이 있어, 한 저장소에 여러 언어를 담는 사용에서는 방해가 됩니다. 그래서 엔진에서 완전히 제거했고 코드 리뷰에서 규칙으로 강제합니다: 어휘 점수가 경로에 끼면 언어별로 검색 품질이 달라지기 때문입니다.

No model runs over your memories.당신의 기억 위엔 모델이 돌지 않습니다.

Storage is verbatim and the engine searches by embeddings - cheap, fast, and deterministic. A model is never run over your stored memories. Tablet uses no model at all; Scroll and Codex add one around the engine for stronger results, but it only ever sees your query, never what you stored.저장은 말한 그대로 두고, 엔진은 임베딩으로 검색합니다 - 저렴하고 빠르고 결정론적입니다. 당신의 저장된 기억 위에선 어떤 모델도 돌지 않습니다. Tablet은 모델을 전혀 쓰지 않고, Scroll·Codex는 더 나은 결과를 위해 엔진 둘레에 모델을 더하지만, 그 모델은 당신의 질문만 볼 뿐 저장한 것은 보지 않습니다.

• Deterministic engine. The engine returns the same memories for the same query, every time - which is why our benchmark variance comes only from the reader model.결정론적 엔진. 엔진은 같은 쿼리에 같은 기억을 반환합니다 - 그래서 벤치마크 편차가 리더 모델에서만 발생합니다.
• Cheap at scale. No generation cost to store or retrieve, so your bill tracks storage - not model usage - as memory grows.대규모에서도 저렴. 저장·검색에 생성 비용이 없어, 기억이 커져도 비용이 모델 사용량이 아니라 저장량을 따라갑니다.

Your words, untouched당신의 말, 그대로

One common design runs a language model at write time to extract and rewrite "facts" from the text. That design trades three things: generation cost on every write, added latency, and storage of a model's paraphrase rather than the original words. WOS makes the opposite trade - it stores what was said, unchanged, and lets your LLM do the interpreting at read time with the original text in hand.쓰기 시점에 언어 모델로 텍스트에서 "사실"을 추출해 다시 쓰는 설계도 흔합니다. 그 설계는 세 가지를 맞바꿉니다: 매 쓰기마다의 생성 비용, 추가 지연, 그리고 원문 대신 모델의 의역이 저장된다는 점. WOS는 반대쪽을 선택했습니다 - 말한 그대로 저장하고, 해석은 읽기 시점에 당신의 LLM이 원문을 들고 하게 합니다.

90.7%, measured and reproducible.측정되고 재현 가능한 90.7%.

90.7% on LongMemEval-S, averaged over 5 independent runs (σ 0.5%, none cherry-picked), graded by the benchmark's canonical GPT-4o judge.LongMemEval-S에서 90.7%, 5회 독립 실행 평균(σ 0.5%, 체리피킹 없음), 벤치마크 표준 채점자인 GPT-4o로 채점.

On the same benchmark, scores vary widely with the grading protocol - the judge, the prompt, and what the retrieval layer is allowed to do. We use the benchmark's canonical third-party GPT-4o judge as published, change nothing to fit the test, and publish the scoring code and reader prompt so anyone can reproduce the 90.7% exactly.같은 벤치마크라도 채점 프로토콜에 따라 수치가 크게 달라집니다 - 채점자, 프롬프트, 검색 레이어에 무엇을 허용하는지에 따라서요. 우리는 벤치마크가 공표한 표준 제3자 GPT-4o 채점자를 그대로 쓰고, 시험에 맞춰 아무것도 바꾸지 않으며, 채점 코드와 리더 프롬프트를 공개해 누구나 90.7%를 그대로 재현할 수 있게 합니다.

The protocol, in one table측정 프로토콜 한눈에

What keeps it honest: a third-party judge, the reader prompt published unchanged, purely semantic retrieval, and every run reported - not just the best. The retrieval engine is deterministic - run it again and you get the same memories.정직하게 유지하는 것: 제3자 채점자, 변경 없이 공개한 리더 프롬프트, 순수 의미 기반 검색, 그리고 최고 회차가 아니라 전 회차 보고. 검색 엔진은 결정론적이라 다시 돌려도 같은 기억이 나옵니다.

We climb harder benchmarks더 어려운 벤치로 올라갑니다

We test on the hardest standard benchmark we haven't yet conquered - and the number is the high-water mark across every WOS model, rewritten each time a better one ships. Clear 94%, and we graduate to a harder benchmark.우리는 아직 정복하지 못한 가장 어려운 표준 벤치마크 위에서 겨룹니다 - 적힌 점수는 모든 WOS 모델이 세운 최고 기록이고, 더 나은 모델이 나올 때마다 새로 쓰입니다. 94%를 넘기는 순간, 더 어려운 벤치마크로 졸업합니다.

Two token rates per model,
plus $0.0001 per request.모델당 토큰 단가 둘,
요청당 $0.0001.

Per million tokens plus a flat $0.0001 per request, pay as you go. No subscription, no storage rent, no memory caps. You pay when your agent writes or reads - never for what it remembers.100만 토큰 단가에 요청당 $0.0001을 더해, 쓴 만큼만. 구독도, 저장료도, 기억 개수 제한도 없습니다. 에이전트가 쓰고 읽을 때만 내고 - 기억하고 있는 것에는 내지 않습니다.

• $0.0001 per request. A flat fee on every API call, on top of token usage.요청당 $0.0001. 모든 API 호출에 붙는 정액 요금으로, 토큰 사용량에 더해집니다.
• Storage is free. Ingest pays once; keeping it costs you nothing. No count limit, no retention limit.저장은 무료입니다. 적재할 때 한 번 내면 보관은 공짜입니다. 개수 제한도, 보관 기간 제한도 없습니다.
• We store it. We never train on it, use it, or look at it. Your agent's memory is yours - we only organize it so you can retrieve it.보관만 합니다. 학습하지 않고, 사용하지 않고, 보지 않습니다. 에이전트의 기억은 당신의 것 - 저희는 회수할 수 있게 정리만 합니다.
• Why Tablet is this cheap: its engine runs no model, so our cost is embeddings and disk - not GPUs. Scroll and Codex add a model, which is what their higher price covers.Tablet이 이렇게 싼 이유: 엔진이 모델을 돌리지 않아 원가가 임베딩과 디스크지 GPU가 아니기 때문입니다. Scroll·Codex는 모델을 더하며, 그 비용이 더 높은 가격에 담겨 있습니다.

Rate limits by usage tier →사용량 티어별 한도 보기 →

Three calls: store, recall, answer.세 번의 호출: 저장, 회수, 답변.

One API. The recall() call returns short-term, long-term, and surrounding context in a single round-trip, ready to drop into your prompt.하나의 API. recall() 호출이 단기·장기 기억과 주변 컨텍스트를 한 번의 왕복으로 돌려줘, 프롬프트에 바로 넣을 수 있습니다.

from wontopos import Client
mem = Client(api_key="wos-...")
mem.add("she prefers tea over coffee", user_id="alice")
# one call: short + long + context
ctx = mem.recall("what does alice drink?", user_id="alice")

Your first recall in 5 minutes.5분 안에 첫 recall.

One key, one install line, three calls - your agent has memory. Every snippet on this page was actually run; responses are shown verbatim.키 하나, 설치 한 줄, 호출 세 번이면 에이전트에 기억이 생깁니다. 이 페이지의 모든 코드는 실제로 실행해 검증했고, 응답도 실물 그대로입니다.

pip install wontopos        # Python
npm install wontopos        # TypeScript / JavaScript
cargo add wontopos          # Rust
# curl - nothing to install, just set WOS_API_KEY

from wontopos import Client

mem = Client(api_key="wos-live-...", user_id="alice")  # set the store once
mem.create_store()              # create it (stores are explicit)
mem.add("she prefers tea over coffee")  # no user_id needed

# one call → short-term + long-term + context
ctx = mem.recall("what does alice drink?")

import { Client } from "wontopos";

const mem = new Client({ apiKey: "wos-live-...", userId: "alice" });  // set the store once
await mem.createStore();            // create it (stores are explicit)
await mem.add("she prefers tea over coffee");  // no userId needed

// one call → short-term + long-term + context
const ctx = await mem.recall("what does alice drink?");

use wontopos::Client;

let mem = Client::new("wos-live-...").with_user("alice");  // set the store once
mem.create_store(None).await?;            // create it (stores are explicit)
mem.add("she prefers tea over coffee", None, json!({})).await?;

// one call → short-term + long-term + context
let ctx = mem.recall("what does alice drink?", None).await?;

# create the store once - stores are explicit
curl -X POST https://api.wontopos.com/api/v1/memory/collection \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice"}'

# store - embedded on the way in, no LLM call
curl -X POST https://api.wontopos.com/api/v1/memory/store \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","content":"she prefers tea over coffee"}'

# one call → short-term + long-term + context
curl -X POST https://api.wontopos.com/api/v1/memory/recall \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","query":"what does alice drink?"}'

{"user_id": "alice", "status": "created"}

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

recall() returns four blocks - short_term (recent turns), long_term (relevant memories), context (what surrounded the best match), and an instruction telling the LLM how to use them. Drop the whole thing into your prompt.recall()은 네 블록을 돌려줍니다 - short_term(최근 대화), long_term(관련 기억), context(가장 관련된 기억의 주변), 그리고 LLM에게 쓰는 법을 알려주는 instruction. 이 덩어리를 그대로 프롬프트에 넣으면 됩니다.

Every method, per language →언어별 메서드 전부 보기 →

Stores - create, list, delete.저장소 - 만들고, 보고, 지우기.

A store is the user_id you read and write under - one isolated memory space per end-user, agent, or topic. Stores are explicit: create one before you store into or recall from it, or the call returns 404. Every account starts with a default store, so you can begin without a create call.저장소는 저장·회수의 단위인 user_id - 최종 사용자·에이전트·주제마다 격리된 기억 공간 하나입니다. 저장소는 명시적이라 저장·회수 전에 먼저 만들어야 하고, 아니면 404가 돌아옵니다. 모든 계정엔 default 저장소가 기본으로 있어 만들지 않고도 바로 시작할 수 있습니다.

mem.create_store("alice")        # create (idempotent)
mem.list_stores()              # [{"user_id","created_at"}, ...]
mem.delete_store("alice")        # delete the store + all its memories

await mem.createStore("alice");
await mem.listStores();          // [{ user_id, created_at }, ...]
await mem.deleteStore("alice");     // store + all its memories

mem.create_store("alice").await?;
let stores = mem.list_stores().await?;
mem.delete_store("alice").await?;

# create
curl -X POST https://api.wontopos.com/api/v1/memory/collection \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" -d '{"user_id":"alice"}'
# list
curl https://api.wontopos.com/api/v1/memory/collections -H "X-API-Key: $WOS_API_KEY"
# delete (store + all its memories)
curl -X DELETE https://api.wontopos.com/api/v1/memory/collection \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" -d '{"user_id":"alice"}'

{ "user_id": "alice", "status": "created" }   // "exists" if it already did

{ "collections": [
  { "user_id": "default", "created_at": "2026-06-26T02:23:14Z" },
  { "user_id": "alice",   "created_at": "2026-06-26T02:24:01Z" }
], "count": 2 }

{ "error": { "type": "not_found_error",
  "message": "Store 'ghost' does not exist. Create it first with
              POST /api/v1/memory/collection {\"user_id\":\"ghost\"}, then store or recall." } }

Python - every method, three groups.Python - 모든 메서드, 세 그룹.

Write, read, delete. Every example below was run against the live API on 2026-06-10; responses are verbatim.쓰고, 읽고, 지우고. 아래 모든 예제는 2026-06-10 라이브 API에서 실제로 실행했고, 응답은 실물 그대로입니다.

pip install wontopos

from wontopos import Client

mem = Client(api_key="wos-live-...")  # or read from an env var

Choose a model모델 선택

mem = Client(api_key="wos-live-...", model="tablet-1")  # default engine
mem.recall("...", user_id="alice")                  # tablet-1
mem.recall("...", user_id="alice", model="tablet-1")  # or pick a model per call

mem.list_models()

[{"id": "tablet-1", "name": "Tablet 1", "available": true, "memory": "shared"}]

The catalog above always reflects the models available right now - pass any other id and you get a clear error. New models appear there automatically when they ship.위 카탈로그는 항상 지금 쓸 수 있는 모델만 보여줘요 - 다른 id를 넣으면 명확한 에러가 돌아와요. 새 모델은 출시되면 자동으로 거기 나타나요.

Write쓰기

mem.add("she prefers tea over coffee", user_id="alice")

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

mem.add_turn("alice", "hi", "hello!")

{"status": "ok"}

mem.add_bulk("Alice moved to Brooklyn in March. She works at a design studio downtown.", user_id="alice")

{"elapsed_secs": 0.154154944, "status": "ok", "stored": 1, "total_chunks": 1}

mem.update("alice", old_memory_id="576700aa-...", new_content="she switched to coffee this year")

{"new_memory_id": "07e94433-b7cc-4e49-8d8f-f37fc1a392b7",
 "old_memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "superseded"}

Read읽기

r = mem.search("what does she drink?", user_id="alice", limit=1)

{"memories": [{
   "id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624",
   "content": "she prefers tea over coffee",
   "category": "general",
   "time_bucket": "2026-06",
   "importance": 0.3,
   "similarity": 0.6316057443618774,
   "is_superseded": false,
   "superseded_by": null,
   "created_at": "2026-06-10T04:20:39.688276876Z"
 }], "search_ms": 315, "total_found": 1}

ctx = mem.recall("what does she drink?", user_id="alice")

{"short_term":  {"count": 2, "turns": [{"role": "user", "content": "hi", ...}]},
 "long_term":   {"count": 4, "memories": [{"content": "she prefers tea over coffee",
                                           "similarity": 0.63, ...}]},
 "context":     {"count": 4, "around_top_memory": [
                  "[match] she prefers tea over coffee",
                  "[after] Alice moved to Brooklyn in March. ..."]},
 "instruction": "Use short_term for recent context, long_term for relevant
                 past memories, context for surrounding conversation of the
                 most relevant memory."}

turns = mem.history("alice")

{"count": 2, "turns": [
   {"role": "user",      "content": "hi",     "timestamp": "2026-06-10T04:20:40.989011337Z"},
   {"role": "assistant", "content": "hello!", "timestamp": "2026-06-10T04:20:40.989013416Z"}
 ], "user_id": "alice"}

mem.stats("alice")

{"short_term_turns": 2, "total_memories": 4, "user_id": "alice"}

Delete삭제

mem.delete("alice", memory_id="576700aa-...")

{"memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "deleted"}

mem.delete_all("alice")

{"memories_deleted": 4, "status": "deleted", "user_id": "alice"}

TypeScript - every method, three groups.TypeScript - 모든 메서드, 세 그룹.

Write, read, delete. Every example below was run against the live API on 2026-06-10; responses are verbatim.쓰고, 읽고, 지우고. 아래 모든 예제는 2026-06-10 라이브 API에서 실제로 실행했고, 응답은 실물 그대로입니다.

npm install wontopos

import { Client } from "wontopos";

const mem = new Client({ apiKey: "wos-live-..." });

Choose a model모델 선택

const mem = new Client({ apiKey: "wos-live-...", model: "tablet-1" });  // default
mem.recall("...", "alice");                          // tablet-1
mem.withModel("tablet-1").recall("...", "alice");  // or pick a model per call

await mem.listModels();

[{"id": "tablet-1", "name": "Tablet 1", "available": true, "memory": "shared"}]

The catalog above always reflects the models available right now - pass any other id and you get a clear error. New models appear there automatically when they ship.위 카탈로그는 항상 지금 쓸 수 있는 모델만 보여줘요 - 다른 id를 넣으면 명확한 에러가 돌아와요. 새 모델은 출시되면 자동으로 거기 나타나요.

Write쓰기

await mem.add("she prefers tea over coffee", "alice");

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

await mem.addTurn("alice", "hi", "hello!");

{"status": "ok"}

await mem.addBulk("Alice moved to Brooklyn in March. She works at a design studio downtown.", "alice");

{"elapsed_secs": 0.154154944, "status": "ok", "stored": 1, "total_chunks": 1}

await mem.update("alice", "576700aa-...", "she switched to coffee this year");

{"new_memory_id": "07e94433-b7cc-4e49-8d8f-f37fc1a392b7",
 "old_memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "superseded"}

Read읽기

const r = await mem.search("what does she drink?", "alice", 1);

{"memories": [{
   "id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624",
   "content": "she prefers tea over coffee",
   "category": "general",
   "time_bucket": "2026-06",
   "importance": 0.3,
   "similarity": 0.6316057443618774,
   "is_superseded": false,
   "superseded_by": null,
   "created_at": "2026-06-10T04:20:39.688276876Z"
 }], "search_ms": 315, "total_found": 1}

const ctx = await mem.recall("what does she drink?", "alice");

{"short_term":  {"count": 2, "turns": [{"role": "user", "content": "hi", ...}]},
 "long_term":   {"count": 4, "memories": [{"content": "she prefers tea over coffee",
                                           "similarity": 0.63, ...}]},
 "context":     {"count": 4, "around_top_memory": [
                  "[match] she prefers tea over coffee",
                  "[after] Alice moved to Brooklyn in March. ..."]},
 "instruction": "Use short_term for recent context, long_term for relevant
                 past memories, context for surrounding conversation of the
                 most relevant memory."}

const turns = await mem.history("alice");

{"count": 2, "turns": [
   {"role": "user",      "content": "hi",     "timestamp": "2026-06-10T04:20:40.989011337Z"},
   {"role": "assistant", "content": "hello!", "timestamp": "2026-06-10T04:20:40.989013416Z"}
 ], "user_id": "alice"}

await mem.stats("alice");

{"short_term_turns": 2, "total_memories": 4, "user_id": "alice"}

Delete삭제

await mem.delete("alice", "576700aa-...");

{"memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "deleted"}

await mem.deleteAll("alice");

{"memories_deleted": 4, "status": "deleted", "user_id": "alice"}

Rust - every method, three groups.Rust - 모든 메서드, 세 그룹.

Write, read, delete. Every example below was run against the live API on 2026-06-10; responses are verbatim.쓰고, 읽고, 지우고. 아래 모든 예제는 2026-06-10 라이브 API에서 실제로 실행했고, 응답은 실물 그대로입니다.

cargo add wontopos

use wontopos::Client;

let mem = Client::new("wos-live-...");

Choose a model모델 선택

let mem = Client::new("wos-live-...").with_model("tablet-1");  // default
mem.recall("...", "alice").await?;                       // tablet-1
mem.with_model("tablet-1").recall("...", "alice").await?;  // or pick a model per call

mem.list_models().await?;

[{"id": "tablet-1", "name": "Tablet 1", "available": true, "memory": "shared"}]

The catalog above always reflects the models available right now - pass any other id and you get a clear error. New models appear there automatically when they ship.위 카탈로그는 항상 지금 쓸 수 있는 모델만 보여줘요 - 다른 id를 넣으면 명확한 에러가 돌아와요. 새 모델은 출시되면 자동으로 거기 나타나요.

Write쓰기

mem.add("she prefers tea over coffee", "alice", json!({})).await?;

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

mem.add_turn("alice", "hi", "hello!").await?;

{"status": "ok"}

mem.add_bulk("Alice moved to Brooklyn in March...", "alice", "general").await?;

{"elapsed_secs": 0.154154944, "status": "ok", "stored": 1, "total_chunks": 1}

mem.update("alice", "576700aa-...", "she switched to coffee this year").await?;

{"new_memory_id": "07e94433-b7cc-4e49-8d8f-f37fc1a392b7",
 "old_memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "superseded"}

Read읽기

let r = mem.search("what does she drink?", "alice", 1).await?;

{"memories": [{
   "id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624",
   "content": "she prefers tea over coffee",
   "category": "general",
   "time_bucket": "2026-06",
   "importance": 0.3,
   "similarity": 0.6316057443618774,
   "is_superseded": false,
   "superseded_by": null,
   "created_at": "2026-06-10T04:20:39.688276876Z"
 }], "search_ms": 315, "total_found": 1}

let ctx = mem.recall("what does she drink?", "alice").await?;

{"short_term":  {"count": 2, "turns": [{"role": "user", "content": "hi", ...}]},
 "long_term":   {"count": 4, "memories": [{"content": "she prefers tea over coffee",
                                           "similarity": 0.63, ...}]},
 "context":     {"count": 4, "around_top_memory": [
                  "[match] she prefers tea over coffee",
                  "[after] Alice moved to Brooklyn in March. ..."]},
 "instruction": "Use short_term for recent context, long_term for relevant
                 past memories, context for surrounding conversation of the
                 most relevant memory."}

let turns = mem.history("alice").await?;

{"count": 2, "turns": [
   {"role": "user",      "content": "hi",     "timestamp": "2026-06-10T04:20:40.989011337Z"},
   {"role": "assistant", "content": "hello!", "timestamp": "2026-06-10T04:20:40.989013416Z"}
 ], "user_id": "alice"}

mem.stats("alice").await?;

{"short_term_turns": 2, "total_memories": 4, "user_id": "alice"}

Delete삭제

mem.delete("alice", "576700aa-...").await?;

{"memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "deleted"}

mem.delete_all("alice").await?;

{"memories_deleted": 4, "status": "deleted", "user_id": "alice"}

curl - no install, same methods.curl - 설치 없이, 같은 메서드.

No SDK to install - any HTTP client works. Set your key once and call the same endpoints the SDKs wrap. Base URL https://api.wontopos.com, auth via X-API-Key, JSON in and out.설치할 SDK가 없습니다 - 어떤 HTTP 클라이언트든 됩니다. 키만 한 번 설정하면 SDK가 감싸는 그 엔드포인트를 그대로 호출해요. Base URL https://api.wontopos.com, 인증은 X-API-Key, 입출력은 JSON.

# set your key once (never hard-code it)
export WOS_API_KEY="wos-live-..."

Write쓰기

curl -X POST https://api.wontopos.com/api/v1/memory/store \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","content":"she prefers tea over coffee"}'

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

curl -X POST https://api.wontopos.com/api/v1/memory/store-turn \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","user_msg":"hi","assistant_msg":"hello!"}'

{"status": "ok"}

curl -X POST https://api.wontopos.com/api/v1/memory/supersede \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","old_memory_id":"576700aa-...","new_content":"she switched to coffee this year"}'

{"new_memory_id": "07e94433-...", "old_memory_id": "576700aa-...", "status": "superseded"}

Read읽기

curl -X POST https://api.wontopos.com/api/v1/memory/search \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","query":"what does she drink?","max_results":1}'

{"memories": [{"id": "576700aa-...", "content": "she prefers tea over coffee",
   "similarity": 0.63, "is_superseded": false}], "search_ms": 315, "total_found": 1}

curl -X POST https://api.wontopos.com/api/v1/memory/recall \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","query":"what does she drink?"}'

{"short_term": {"count": 2, "turns": [...]},
 "long_term":  {"count": 4, "memories": [{"content": "she prefers tea over coffee", "similarity": 0.63}]},
 "context":    {"count": 4, "around_top_memory": ["[match] she prefers tea over coffee"]},
 "instruction": "Use short_term for recent context, long_term for relevant past memories..."}

Delete삭제

curl -X POST https://api.wontopos.com/api/v1/memory/forget \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice"}'  # omit memory_id = delete all

{"memories_deleted": 1, "status": "deleted", "user_id": "alice"}

Every endpoint + body fields →엔드포인트 + 바디 필드 전부 보기 →

Engrams

Callable recall tools your model can invoke - each one a different retrieval strategy over the same memory. Use one, or run several at once.모델이 호출하는 회수 도구 - 같은 기억 위에서 서로 다른 검색 전략을 씁니다. 하나만 쓰거나 여러 개를 동시에 호출하세요.

More engrams ship regularly - this list grows.엔그램은 계속 추가됩니다 - 목록은 늘어납니다.

Memoir & Archive회고록 & 아카이브 Coming soon곧 나옴

This one is a model mode, not a callable tool. Pick it on the model and every recall, a plain search included, comes back with time written that way. Coming soon.이건 호출하는 도구가 아니라 모델 모드입니다. 모델에서 고르면 그냥 검색을 포함한 모든 회수에 시간이 그 방식으로 적혀 돌아옵니다. 곧 나옴.

Time_awareness Coming soon곧 나옴

A model mode, not a per-call option. Pick the model - Time_awareness-memoir or Time_awareness-archive - and every recall comes back rendered that way: a plain search, a recall, or any engram, no extra parameter. A Memoir reads the way a person remembers; an Archive keeps an exact record - the difference shows up most in how each writes time. The Time_awareness- prefix leaves room for more capabilities later.호출 옵션이 아니라 모델 모드. 모델(Time_awareness-memoir 또는 Time_awareness-archive)을 고르면 - 그냥 검색이든 recall이든 엔그램이든 - 추가 파라미터 없이 모든 회수가 그 방식으로 돌아옵니다. 회고록은 사람이 기억하듯, 아카이브는 정확한 기록 그대로 - 차이는 시간을 적는 방식에서 가장 잘 드러납니다. Time_awareness- 접두는 앞으로 다른 능력이 들어올 자리를 남깁니다.

# plain search - no engram - on a memoir model
r = mem.search("what does Alice drink?", user_id="alice", model="Time_awareness-memoir", tz=9)
# every hit gets a .time field → "a couple weeks ago"  (archive model → "2 weeks ago (Jun 09)")

// plain search - no engram - on a memoir model
const r = await mem.withModel("Time_awareness-memoir").search("what does Alice drink?", "alice", 10, { tz: 9 });

// model picks the mode; tz over HTTP via the X-WOS-Timezone header
let r = mem.with_model("Time_awareness-memoir").search("what does Alice drink?", "alice", 10).await?;

curl -X POST https://api.wontopos.com/api/v1/memory/search \
  -H "X-API-Key: wos-live-..." -H "X-WOS-Model: Time_awareness-memoir" -H "X-WOS-Timezone: 9" \
  -d '{"user_id":"alice","query":"what does Alice drink?"}'
# each memory comes back with a "time" field; use Time_awareness-archive for exact time

tz is the caller's UTC offset in hours - so "this morning" and the 4am day boundary land in their local time. Omit it for UTC; over HTTP it's the X-WOS-Timezone header. Roughly, by region: US East -5, US Central -6, US West -8 · UK / Lisbon 0 · Central Europe +1 · Eastern Europe +2 · India +5.5 · China / Singapore +8 · Korea / Japan +9 · Sydney +10. (Standard time - daylight saving shifts some regions by +1; pass whatever your users are actually on.)tz는 호출자의 UTC 오프셋(시간) - 라 "this morning" 같은 표현과 새벽 4시 경계가 그 사람 현지 시간으로 찍힙니다. 안 주면 UTC, HTTP에선 X-WOS-Timezone 헤더. 지역별 대략값: 미국 동부 -5, 중부 -6, 서부 -8 · 영국 / 리스본 0 · 중부 유럽 +1 · 동유럽 +2 · 인도 +5.5 · 중국 / 싱가포르 +8 · 한국 / 일본 +9 · 시드니 +10. (표준시 기준 - 서머타임이면 일부 지역은 +1, 사용자가 실제로 쓰는 값을 그대로 넣으세요.)

Same search, two models - the memories are identical, only time changes:같은 검색, 두 모델 - 기억은 똑같고 time만 달라집니다:

{ "count": 3, "memories": [
  { "content": "Alice prefers tea over coffee", "time": "a couple weeks ago" },
  { "content": "met Alice at the cafe downtown",  "time": "yesterday afternoon" },
  { "content": "Alice moved to Brooklyn",          "time": "about half a year ago" }
] }

{ "count": 3, "memories": [
  { "content": "Alice prefers tea over coffee", "time": "2 weeks ago (Jun 09)" },
  { "content": "met Alice at the cafe downtown",  "time": "yesterday at 14:00" },
  { "content": "Alice moved to Brooklyn",          "time": "6 months ago (Dec 2025)" }
] }

Every value above is the renderer's real output. Look at the two "yesterday" rows: a Memoir splits afternoon from last night - a day is one sleep - while an Archive writes a single clock time and draws no day or night line.위 값은 전부 렌더러의 실제 출력입니다. "어제" 두 줄을 보세요: 회고록은 낮과 밤을 가르지만 - 하루는 잠 한 번 - 아카이브는 시계 시각 하나로 적고 낮·밤을 나누지 않습니다.

How each mode reads time모드별 시간 읽는 법

Memoir - the way people actually say it. Recent moments stay fairly sharp (about 15 minutes, half an hour), then the wording widens the further back you go - a couple weeks, about half a year, a couple years - the way memory itself loosens with distance. Inside a day it drops the clock for a landmark: this morning, last night, yesterday afternoon. And a day is one sleep, not a calendar tick: the boundary sits around 4am local time, so a late night still reads as the same evening, not already tomorrow.회고록 - 사람이 실제로 말하는 방식. 최근은 비교적 또렷하다가(약 15분 전, 30분 전) 멀어질수록 표현이 넓어집니다 - 2주쯤 전, 반년쯤 전, 몇 년 전 - 기억 자체가 멀수록 풀어지듯. 하루 안에서는 시계 대신 landmark를 씁니다: 오늘 아침, 어젯밤, 어제 오후. 그리고 하루는 달력 한 칸이 아니라 잠 한 번: 경계가 현지 새벽 4시쯤이라, 늦은 밤도 여전히 '오늘 밤'으로 읽히지 벌써 내일이 되지 않습니다.

Archive - precise, always with an anchor. Every line carries the exact elapsed time plus an absolute reference a model can compute from, and the anchor tightens as it nears: a clock for today (8 hours ago, at 07:10), a weekday and clock this week (2 days ago (Tue 15:10)), a date this month (last week (Jun 16)), a month and year beyond (6 months ago (Dec 2025)). Never vague, never wrong.아카이브 - 정밀, 항상 앵커와 함께. 모든 줄에 정확한 경과 시간 + 모델이 계산할 수 있는 절대 기준이 붙고, 가까울수록 앵커가 촘촘해집니다: 오늘은 시계(8시간 전, 07:10), 이번 주는 요일+시계(2일 전 (화 15:10)), 이번 달은 날짜(지난주 (6월 16일)), 그 너머는 월·연도(6개월 전 (2025년 12월)). 모호함 없이, 틀림 없이.

deep_recall

Multi-hop recall. Searches your query, then takes the top match and searches again on its content - pulling in linked context a single search would miss. Best when memories reference each other (a person → their projects → details). Returns up to ~12.멀티홉 회수. 쿼리로 검색한 뒤 최상위 매치의 내용으로 한 번 더 검색해 단일 검색이 놓칠 연결 맥락을 끌어옵니다. 기억이 서로를 참조할 때(사람 → 프로젝트 → 세부) 가장 좋습니다. 최대 ~12개.

out = mem.engram("deep_recall", "what should I know about Alice?", user_id="alice")

const out = await mem.engram("deep_recall", "what should I know about Alice?", "alice");

let out = mem.engram("deep_recall", "what should I know about Alice?", "alice").await?;

curl -X POST https://api.wontopos.com/api/v1/engram/run \
  -H "X-API-Key: wos-live-..." -H "Content-Type: application/json" \
  -d '{"name":"deep_recall","user_id":"alice","query":"what should I know about Alice?"}'

{ "engram": "deep_recall", "hops": 2, "count": 12,
  "memories": [ ... ],
  "usage": { "input_tokens": 5, "output_tokens": 61 } }

timeline

Time-ordered recall. Returns memories sorted newest-first by when the event happened, not by relevance. For "when did X", history, and sequence questions. Returns up to 15.시간순 회수. 관련도가 아니라 사건 발생 시점 기준 최신순으로 정렬해 반환합니다. "언제 X했지", 이력, 순서 질문에. 최대 15개.

events = mem.engram("timeline", "project milestones", user_id="alice")

const events = await mem.engram("timeline", "project milestones", "alice");

let events = mem.engram("timeline", "project milestones", "alice").await?;

curl -X POST https://api.wontopos.com/api/v1/engram/run \
  -H "X-API-Key: wos-live-..." -H "Content-Type: application/json" \
  -d '{"name":"timeline","user_id":"alice","query":"project milestones"}'

{ "engram": "timeline", "hops": 1, "count": 15,
  "memories": [ ... ],
  "usage": { "input_tokens": 4, "output_tokens": 88 } }

gather

Broad gather. Searches, then expands around the top three matches - a wider net than deep_recall. Use it to pull in everything related to a person, project, or topic in one call. Returns up to ~18.넓은 수집. 검색 후 상위 세 매치 주변을 확장해 deep_recall보다 더 넓게 훑습니다. 한 사람·프로젝트·주제 관련된 걸 한 번에 다 모을 때. 최대 ~18개.

related = mem.engram("gather", "everything about Project Atlas", user_id="alice")

const related = await mem.engram("gather", "everything about Project Atlas", "alice");

let related = mem.engram("gather", "everything about Project Atlas", "alice").await?;

curl -X POST https://api.wontopos.com/api/v1/engram/run \
  -H "X-API-Key: wos-live-..." -H "Content-Type: application/json" \
  -d '{"name":"gather","user_id":"alice","query":"everything about Project Atlas"}'

{ "engram": "gather", "hops": 4, "count": 18,
  "memories": [ ... ],
  "usage": { "input_tokens": 6, "output_tokens": 142 } }

Every endpoint, one base URL.모든 엔드포인트, 하나의 Base URL.

No SDK required - any HTTP client works. Base URL https://api.wontopos.com, auth via the X-API-Key header, JSON in and out. Memory ops are POST; managing stores uses POST / GET / DELETE on /collection. A store must exist first (see Stores) or in-store ops return 404.SDK 없이도 됩니다 - 어떤 HTTP 클라이언트든 가능. Base URL https://api.wontopos.com, 인증은 X-API-Key 헤더, 입출력은 JSON. 기억 작업은 POST, 저장소 관리는 /collection에 POST / GET / DELETE. 저장소가 먼저 있어야 하고(Stores 참고), 없으면 404.

# create the store once (stores are explicit)
curl -X POST https://api.wontopos.com/api/v1/memory/collection \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice"}'

# store a memory
curl -X POST https://api.wontopos.com/api/v1/memory/store \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","content":"she prefers tea over coffee"}'

# recall - one call, ready for your prompt
curl -X POST https://api.wontopos.com/api/v1/memory/recall \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","query":"what does alice drink?"}'

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

Same features for everyone.
Tiers only raise your limits.기능은 모두에게 동일.
티어는 한도만 올립니다.

Every tier runs the full engine - same recall quality, same languages, every method. Tiers advance automatically through Tier 5 as your cumulative credit purchases grow, with no application or sales call. Enterprise (Tier 6) is the one exception.모든 티어가 같은 엔진을 씁니다 - 같은 recall 품질, 같은 다국어, 모든 메서드. Tier 5까지는 누적 충전액이 쌓이면 신청이나 영업 통화 없이 자동으로 올라갑니다. Enterprise(Tier 6)만 예외입니다.

Spend limits지출 한도

Each tier caps how much you can spend per calendar month. You advance immediately when your cumulative credit purchases reach the next threshold.티어마다 한 달에 쓸 수 있는 금액에 상한이 있습니다. 누적 충전액이 다음 기준에 도달하면 즉시 승급됩니다.

Rate limits속도 한도

Rate limits are per account - every API key on an account shares one limit, which scales with your tier. Exceeding it returns a 429 with a retry-after header; back off (1s → 2s → 4s) and retry. Every endpoint is idempotent-friendly, so retries are safe.속도 한도는 계정 단위입니다 - 한 계정의 모든 API 키가 하나의 한도를 공유하며, 티어에 따라 올라갑니다. 넘으면 retry-after 헤더와 함께 429를 돌려주므로, 잠시 물러났다(1초 → 2초 → 4초) 재시도하면 됩니다. 모든 엔드포인트가 멱등에 친화적이라 재시도해도 안전합니다.

Enterprise (Tier 6) gets custom rate limits, an SLA, dedicated support, and an optional self-host license - talk to us.Enterprise(Tier 6)는 커스텀 한도, SLA, 전담 지원, 그리고 선택적 self-host 라이선스를 제공합니다 - 문의하세요.

When something goes wrong.문제가 생겼을 때.

Errors come back as a JSON envelope with a stable type, a human message, and a request_id you can send us when reporting an issue.에러는 안정적인 type, 사람이 읽는 메시지, 그리고 문의 시 함께 보낼 수 있는 request_id가 담긴 JSON 봉투로 옵니다.

{"type": "error", "error": {
   "type": "authentication_error",
   "message": "Invalid or revoked API key.",
   "request_id": "063f8b83-eee2-4383-a5cf-11e4bcd29d7c"
 }}

# SDK error handling (Python)
from wontopos import Client, WosError

try:
    mem.search("...", user_id="alice")
except WosError as e:
    if e.status == 401: ...  # bad key
    elif e.status == 429: ...  # back off and retry

Rate limits are per account, shared across all your keys, and scale with your tier - see Usage tiers. Your account's usage is shown in the console.요청 한도는 계정 단위로 모든 키가 공유하며, 티어에 따라 올라갑니다 - 사용량 티어 참고. 계정 사용량은 콘솔에 표시됩니다.

Your servers, your data.당신의 서버, 당신의 데이터.

The engine can run inside your own infrastructure - same API, same SDKs. Point the client at your host and nothing else changes.엔진을 자체 인프라에서 운영할 수 있습니다 - 같은 API, 같은 SDK. 클라이언트가 바라보는 주소만 바꾸면 나머지는 그대로입니다.

mem = Client(api_key="...", base_url="https://wos.your-host.com")

const mem = new Client({ apiKey: "...", baseUrl: "https://wos.your-host.com" });

let mem = Client::with_base_url("...", "https://wos.your-host.com");

• Data residency. Memories never leave your network.데이터 주권. 기억이 당신의 네트워크 밖으로 나가지 않습니다.
• Same surface. The same methods and endpoints work identically.동일한 인터페이스. 같은 메서드와 엔드포인트가 동일하게 동작합니다.
• Licensing. Self-host packages are arranged per deployment - contact us.라이선스. 셀프 호스팅 패키지는 배포 단위로 협의합니다 - 문의하기.

Beyond the context window.컨텍스트 윈도를 넘어서.

WOS recalls from histories of 1.4M tokens - far larger than any LLM context window - and still hands back a tight ~1,470-token slice.WOS는 어떤 LLM 컨텍스트 윈도보다도 큰 140만 토큰 히스토리에서도 회수하고, 여전히 ~1,470 토큰의 짧은 조각만 돌려줍니다.

Your agent's memory isn't capped by what fits in a prompt. It keeps everything and retrieves only what matters, no matter how large the history grows.에이전트의 기억은 프롬프트에 들어가는 양에 갇히지 않습니다. 전부 보관하고 중요한 것만 회수합니다. 히스토리가 아무리 커져도 마찬가지입니다.

Private, and yours.비공개, 그리고 당신의 것.

Your data stays in your store. We never train on it, view it, or reuse it - we only organize it so you can retrieve it.데이터는 당신의 저장소에 머뭅니다. 저희는 그것으로 학습하지도, 열람하지도, 재사용하지도 않습니다 - 회수할 수 있게 정리만 합니다.

• BYOK. Your LLM key is sent per request and never stored.BYOK. LLM 키는 요청마다 전달되며 저장되지 않습니다.
• Isolated. Memories are scoped per account, then per user_id.격리. 기억은 계정별, 그리고 user_id별로 분리됩니다.
• GDPR delete & self-host. One call wipes a user; run the engine in your own environment if you prefer.GDPR 삭제 & 셀프 호스팅. 한 번의 호출로 사용자를 삭제하고, 원하면 엔진을 자체 환경에서 운영할 수 있습니다.