What shipped

Kognite is under active development. Every entry below maps to a real change in the running system — including the ones that corrected something we had previously got wrong.

1. September 16, 2026DeveloperProduct

   Connect from the MCP registry without creating a key first

   • The MCP registry listing now uses the sign-in URL. Kognite's entry in the official MCP registry (`dev.kognite/memory`, version 1.1.0) points at `https://mcp.kognite.dev/mcp`. A client installed from the registry, or from a directory that mirrors it, opens a browser tab where you sign in and approve the connection, and the first sign-in creates your account. The listing used to advertise `https://mcp.kognite.dev/t/{api_key}`, so connecting required an account and a key before the client could reach the server at all. The story behind the change is on the blog.
   • The docs lead with the same URL. /docs/quickstart, /docs/mcp-clients and the /memory-for guides for Claude Code, Cursor, Claude Desktop and ChatGPT now start with adding the server and approving it in the browser; creating a key is no longer step one, and the three steps on the home page follow the same order. The ChatGPT guide no longer tells you to set authentication to None.
   • Keys keep working. For clients that can't do the browser handshake, the key URL `https://mcp.kognite.dev/t/<key>`, an `Authorization: Bearer` header and a `?token=` parameter all work exactly as before and stay documented on /docs/mcp-clients.
   • The dashboard's Connect page defaults to sign-in. It leads with `https://mcp.kognite.dev/mcp` and per-client steps for approving in the browser — Claude Code is now listed too — with a connection key one click away for clients that need it. One-click Add for Cursor and VS Code no longer waits for a key.
   • An empty memory says so. On a newly connected account, `memory_search` and `context_assemble` used to return a bare empty list, which an agent can read as "search is broken". They now add a `hint` explaining that nothing has been saved yet and to store facts with `memory_add` or `episode_log`.
   • The sign-in page names the app that sent you. Arriving from a client's connect flow, /login now says which application wants to connect, and that you approve its access on the next screen.
2. September 10, 2026Product

   A sign-in page that explains what you're signing in to

   • app.kognite.dev/login is now a landing page. Arriving there straight from a registry listing or a link, you see what Kognite is, the three steps after signing in, and live production counters — memories stored, tool calls in the last seven days, and when the last memory was written — with a link to try the demo memory first.
   • "Sign in or start free." The form no longer greets first-time visitors with "Welcome back". It is the same passwordless sign-in either way, and your first sign-in creates the account — free, no card.
3. September 4, 2026ProductSecurity

   Memory formation now runs on Claude Sonnet 5

   • Fact and knowledge-graph extraction moved to Anthropic's Claude Sonnet 5. When a conversation is logged, the model that turns it into atomic, dated, third-person memories and graph entities is now Claude Sonnet 5 via the Claude API, with light adaptive reasoning. On our extraction test set it produced the cleanest facts of every model we compared (including gpt-5-mini, gpt-5-nano and the previous provider), with no invented dates or mis-attributed people.
   • The provider is pinned. The API uses exactly one LLM vendor or none; it no longer falls back to whichever other key happens to be present in its environment.
   • Subprocessor list corrected, DPA names the model. Anthropic, PBC (United States, SCCs; no training on API data) is now listed in the privacy policy, and the DPA template gained a clause stating the model (Claude Sonnet 5), exactly what is sent to it, and a 30-day notice commitment before any change of model provider. The previous extraction provider, DeepSeek, had been in use since July 2026 without appearing on that list — an omission on our side, now closed: it is gone from the product, its configuration and the benchmark harness.
4. September 3, 2026PlatformDeveloper

   A steadier embedding service, faster reranked search, and a health check that means it

   • The embedding and rerank service no longer runs out of memory. It processed each request as one model batch, and the runtime keeps the memory of the largest batch it has ever seen, so a single large request set the process's floor for good and it was eventually killed — during which searches silently lost their semantic half and new memories waited for vectors. Inputs are now fed to the models eight at a time; the worst permitted request peaks at about 1 GB instead of growing without bound.
   • Reranked searches are about 20% faster (the MCP default): smaller batches stop short memories from being padded to the longest one, and text past what the cross-encoder can read (512 tokens) is no longer shipped to it. Un-reranked search is unchanged at under 100 ms.
   • `/api/health` now checks the database and cache. It answered ok unconditionally; it now returns 503 when Postgres is unreachable and reports the state and latency of each dependency, so the deploy gate and uptime monitor can see a real outage.
   • Knowledge-graph links are cleaned up with what they link. Deleting a memory or entity now removes its graph links automatically (foreign keys with cascade); 175,000 stale link rows left behind by an earlier purge were removed.
   • Internal hardening: per-query statistics and slow-query logging are on in Postgres, the API keeps its database connections warm instead of reconnecting on nearly every request, and the cache now requires the credential the services were already sending.
5. September 2, 2026DeveloperPlatformProduct

   Tool errors you can act on, sturdier memory formation, and a sweep of quiet defects

   • MCP tool failures now tell the model what happened. A stale memory id, an exhausted monthly quota, the daily search cap, a read-only key, an oversized payload — each comes back as a readable tool result instead of the generic "MCP error -32603" that clients rendered as a broken server. An unreachable API is reported as a temporary outage (503, retry) rather than as an invalid key.
   • Long conversations log without duplicates. `episode_log` used to be cut off at 30 seconds while extraction kept running upstream; the retry stored a second set of facts. The call now waits up to 90 seconds and, if it still times out, says plainly that the memories will land and not to resend.
   • Memory formation no longer loses whole chunks. Extraction output that hit the token limit was discarded entirely; the complete facts are now kept, the output budget is larger, transient provider failures are retried, and the ingest response reports how many chunks (if any) failed. Knowledge-graph extraction that hits a provider hiccup is retried on later passes instead of being marked done forever.
   • Replaying an idempotency key after a delete stores the new memory. Previously it matched the deleted row and returned its id as if stored. Replays of a live key now answer 200 with `replayed: true`.
   • Inputs are checked before they hit the database. A bad `kind`, a confidence outside 0–1, a non-numeric limit, or a malformed memory id now answer 422/404 instead of 500.
   • The dashboard reads every workspace you own. The knowledge graph and usage cards only read your personal workspace while the Memories page spanned all of them; the billing meter now shows this month's count for your busiest workspace — the number the quota actually enforces. The GDPR processing-record list, which filtered on an action nothing wrote, now lists deletes and exports; audit date ranges include the last selected day; referral codes are generated on first visit.
   • API keys mean what you selected. Permission toggles the server never supported were removed; an unknown grant is refused instead of silently minting a full read/write key. A deleted account's sign-in session now ends within five minutes.
   • Share previews are back. The Open Graph image behind every link preview had been failing since the redesign.
   • Retired the never-functional SSE transport (streamable HTTP is the only one; the URL is unchanged), and gateway logs now distinguish crawler noise from a real credential being refused.
   • Sign in from your MCP client — no key to paste. The gateway now speaks OAuth 2.1 as the MCP authorization spec describes it: add `https://mcp.kognite.dev/mcp` in Claude Code, Cursor, VS Code, Claude.ai or ChatGPT, approve the request in your browser, and the client holds a short-lived token it refreshes on its own. Personal access tokens keep working exactly as before. Connected applications can be reviewed and revoked from the API Keys page.
   • One deduplication key for every way a memory can arrive. Direct writes and conversation ingest hashed content differently, so the same fact stored both ways landed twice; historical rows were recomputed under the shared formula.
   • Rate limits apply to tool calls, not handshakes. Connecting a client (initialize, tool listing, pings) no longer spends the per-minute budget, and a refused call comes back as a readable tool result with the retry delay instead of an HTTP 429 the client reports as a dead server.
   • Re-sending a conversation costs nothing. Turns already stored in your workspace are dropped before extraction runs and before quota is counted; the response reports how many were deduplicated.
   • Marketplace purchases now deliver. Buying or installing a skill copies the listed version into your workspace as a private skill (My Purchases links to it); template installs add their starter memories. Sellers can only list skills they own.
   • Deleting your data cancels your paid plan. The self-serve GDPR delete cancels any Stripe subscription immediately and says so in the preview; the plan tier now follows the price you are actually on, so a change made in the billing portal takes effect.
   • Search relevance scores stay consistent across a page that mixes reranked and fusion-ranked hits; the knowledge graph can no longer create duplicate entities under concurrent extraction; the admin usage page labels response volume as bytes rather than tokens.
6. August 31, 2026ProductSecurityPlatform

   New sign-in options, an audit trail for everything, and a security sweep

   • One-click sign-in with Google and GitHub. Both are live alongside email sign-in links. A Google sign-in on an email that already has an account links to it and signs you straight in (safe because Google verifies email ownership and we enforce that check server-side); and when a sign-in can't proceed, the page now tells you exactly why and what to do instead of silently returning you to the form.
   • Every account action now leaves an audit record. Key creation and revocation, memory deletion and restore, skill publishing, retention-policy changes, marketplace activity, billing events — all of it lands in your audit log, alongside the GDPR processing records that were already there. Your data-plane traffic (memory add/search) is metered separately and deliberately kept out of the audit log.
   • Permissions now bind everywhere. A full audit of every API surface found — and closed — the gaps: account deletion, and skill create/publish/delete, all now require a write-scoped key (read-only keys are truly read-only), suspending an account now cuts API and MCP access immediately (not just dashboard login), and API keys no longer appear in any server log.
   • Data deletion is now provably complete. A sweep of the erasure paths found steps that could fail silently while the interface reported success — including one that failed on every run. Deletion now verifies every step and tells you plainly if anything needs a re-run, and the processing record it promises is actually visible on your audit page.
   • The interface only claims what the system does. Placeholder usage numbers, an unreachable category filter, controls that advertised features that weren't wired, and compliance statements that overstated the stack are gone — every tile, filter, and status on the dashboard now reflects the real system state, and failed loads say so instead of rendering confident zeros.
   • Down means a page within minutes. Independent probes now check the landing page, dashboard, REST API, and MCP gateway every two minutes from a separate host, with one alert on failure and one on recovery — the alert path was drill-tested, not assumed.
   • Getting connected is now the product's job, not yours. The dashboard shows a live banner until your agent's first real call lands, pointing at the Connect page with per-client config. If you sign up and stall, one short email arrives the next day with the two-minute path — never more than one.
   • Faster, leaner storage: internal benchmark fixtures were purged from the production database (149 MB → 45 MB) after a rehearsed restore drill, and the signup funnel is now measured end-to-end so every onboarding change is judged by data instead of feel.
7. July 25, 2026ProductSecurity

   A landing page that shows the system instead of describing it

   • The home page now renders a live memory graph rather than a stock illustration — entities, relationships, and the edges Kognite actually builds between them.
   • /benchmarks gained a dumbbell plot that puts every measured configuration on one axis, so the spread between retrieval recall and end-to-end answer accuracy is visible at a glance instead of buried in a table.
   • /docs gained a surface map: every tool, endpoint, and MCP capability on one page, so you can see the whole API before reading any of it.
   • Patched Next.js from 15.0.4 to 15.5.21, closing the advisories accumulated across that gap, and repaired the ESLint config that had been silently passing everything.
8. July 15, 2026DeveloperBenchmarksPlatform

   Official SDKs, nightly backups, and an end-to-end benchmark

   • TypeScript and Python SDKs. `@kognite/sdk` (zero dependencies) and `kognite` (stdlib only) cover memories add/search/list/get/forget/ingest, context.assemble, graph.query, and health — with retry, backoff, and typed errors. Every method was verified against the live API before release.
   • End-to-end benchmark published. Earlier numbers measured retrieval in isolation. The new run ingests the LoCoMo corpus through the real formation pipeline and answers all 1,542 questions using only what the live API returns: 71.4% accuracy, and 70.0% when re-judged by GPT-4o — the same judge behind Mem0's published band, so the two are directly comparable.
   • The grader is decoupled from the system under test. The benchmark harness can now be pointed at a judge model that has nothing to do with the one answering, which is what let us re-score the identical run with GPT-4o — the judge behind Mem0's published numbers — instead of only with our own. That is why the 70.0% figure is comparable to theirs rather than to itself. The harness is not published yet, so for now you are still taking our word for the run; making it reproducible outside our infrastructure is the obvious next step. (Published 2026-08-07: github.com/global-software-development-eu/kognite-benchmark, MIT — see /benchmarks.)
   • Nightly backups with a proven restore. A pg_dump runs at 03:15 UTC on the database host and is pulled off-box at 03:45, keeping 7 and 14 days respectively. The restore was drilled, not assumed: 15,867 memories were restored into a scratch database and verified.
   • Rate limiting fixed at the edge. The limiter was keying on the CDN's IP rather than the caller's, so every request behind the CDN shared one bucket. It now keys on the forwarded client IP.
   • Closed the P0 findings from the 9 July load audit.
9. July 9, 2026PlatformSecurity

   Billing, admin, and the end of the mock database

   • Production refuses to start on a mock database. The API and MCP gateway could previously fall back to an in-memory stub in production if a connection string was missing — failing silently instead of loudly. That path is now a hard refusal.
   • Checkout was broken for everyone. An invalid Stripe API version rejected every checkout session. Fixed, and plan changes now route through the Stripe customer portal with rank-aware upgrade and downgrade buttons.
   • Pricing ladder reworked and migrated to Stripe `lookup_key`s, so plan pricing can change without redeploying.
   • Trash for memories. Soft-deleted memories are now browsable and restorable rather than invisible until purge.
   • Deleting a memory cleans up its graph. Knowledge-graph entities left orphaned by a delete are now cascaded.
   • Personal access token permissions are enforced, `/metrics` is gated, and the per-scope quota check fails closed instead of open.
   • Deploy smoke tests actually test something — they previously passed on a dead deployment, and now fail the deploy when they fail.
   • Marketplace purchases are idempotent (unique index plus ON CONFLICT), so a retried request cannot double-charge.
   • Sitemap, robots.txt, and canonical URLs onto the apex domain.
10. July 3, 2026SecurityRetrievalBenchmarks

    Cross-tenant leak closed, four broken MCP tools implemented, honest benchmarks

    • Cross-tenant audit-log leak closed. The audit-log endpoint did not require authentication or filter by scope, so one tenant could read another's audit trail. It now requires auth and filters by scope. This was the most serious finding of the security audit and is fixed.
    • Four MCP tools that were advertised but not implemented now work, and upstream failures surface as errors instead of empty results. The gateway also stopped advertising a `logging` capability it never had.
    • Cross-encoder reranking is on by default for `memory_search`, with normalized scores, deterministic graph ordering, and dedup at ingest.
    • The 91.8% benchmark chart was wrong and has been replaced. The published comparison against Mem0 was not measured on the same harness. The new numbers run both systems over the identical LoCoMo corpus with the same embedder, the same judge, and the same recall method — only the retrieval engine differs. Kognite's number went down and it is now true.
    • Admin control plane. User management, a global audit view, an admin action trail, first-party visitor analytics, and durable API usage accounting.
    • Cost and abuse controls: input bounds, per-scope quotas, and rate limiting.
    • GDPR export now includes episodes; OAuth failures report the real error; the retention-policies list no longer 500s.

Subscribe via RSS. The numbers behind the benchmark entries are on /benchmarks, and they are re-run rather than restated.