Changelog

If you're building your own agent, you can now authenticate to MemHub with a personal access key instead of the interactive browser login a headless loop can't do. Mint one with a single API call, drop it in an environment variable, and point any MCP client — or a plain HTTP call — at MemHub as yourself.

A key acts as you, at one seat's throughput — so it's a teammate, not a firehose for a multi-tenant app. You can scope a key read-only, hold several at once (mint a new one and revoke the old to rotate without downtime), and revoke any of them instantly. It drives MemHub's own memory over the MCP server or the REST API, and can mint and manage your Memory API keys — read the guide.

As a team fills MemHub with brains, finding the right one shouldn't mean scrolling. The brains page now has stackable filters — narrow by who owns a brain, who it's shared with, its category or status, or when it was created or last updated — and sorts on any of those.

Lay them out however you work: a compact List, a Board of cards, or Sections grouped by folder, with drag-and-drop to move a brain into a folder right from the list. The layout you pick sticks between visits.

If the context your team works from lives in HubSpot, your agents have been working without it. Connect a HubSpot account from Integrations and its Contacts, Companies, and Deals become something an agent can read in chat — and write back to — rather than something you paste in by hand.

Routines can use the CRM too — reads only, and opted into per routine rather than inherited, so a routine can't reach your CRM by accident.

An agent that has to guess halfway through a task usually guesses wrong. Runs can now suspend, ask you a question, and resume from the same place once you answer — so a routine that needs a recipient, a date, or a judgment call stops and asks instead of inventing one.

Questions render inline in the conversation and accept multiple selections where the answer isn't one-of. Anything waiting on you is flagged on the Studio board and badged in the nav, so a suspended run doesn't sit unnoticed.

Starting from an empty workspace is the hardest part of adopting MemHub. Explore is a curated catalog of skills and routines you can add in one click — and when an entry needs a brain to work against, adding it creates that brain for you.

Catalog entries carry their own setup: routines that run on a schedule get a real schedule picker, and ones that email a teammate get a recipient picker. Browse by category to narrow it down.

You can now buy compute credits up front rather than settling overage after the fact, and set auto-reload so a long-running agent doesn't stall mid-task. Auto-reload takes a monthly cap, so topping up automatically can't run away from you.

Memory API usage now reconciles into the same credit balance as MemHub — one number for both products instead of two meters to reason about. Credit purchases appear on your invoice, and the top-up history is filterable by date range.

Studio replaces the portal surfaces MemHub grew piecemeal over the last few months. Brains, routines, skills, and the work your agents are doing now live in one place, on one board, instead of being scattered across pages that each knew about a different part of the system.

The retired surfaces are gone rather than deprecated, and old bookmarks redirect instead of 404ing.

Watching an agent head down the wrong path and having to stop it, rewrite the prompt, and start over is the most wasteful thing in agent chat. You can now steer a run while it's happening: type the correction into the composer and the agent takes it from there, keeping everything it has already done.

A steered turn renders as what it actually is — the response so far, your correction, then the continuation — and it survives a reload in that same shape. Runs are resumable, so closing the tab no longer kills the work.

MemHub used to meter messages, runs, and API calls separately, which made it impossible to answer "what is this costing me?" without adding up three numbers. There is now one meter: compute credits, with an itemized spend log showing what each run consumed.

Overage is card-gated rather than surprising, Pro and Scale no longer cap members (only Free does, at 5), and the Free plan's agent-brain limit went from 3 to 15. Annual billing is two months free — the old "20%" copy was wrong.

Chat has been rebuilt from the composer up. Every tool call the agent makes now renders — not just code execution — and reasoning streams as the agent thinks rather than appearing after the fact. Reloading a conversation replays it in the order it actually happened, text then tool then text, instead of collapsing into a summary that didn't match what you watched.

You can attach images and PDFs to a message and the model sees them in the same turn, with an explicit tool for keeping an attachment in a brain rather than having it silently vanish when the conversation ends.

Routines were authorable from chat but invisible afterwards. They now have a proper section: the list, each routine's detail, and the history of every run it has made.

Routines also got more capable this release. They can pull from the web while they run, produce binary file deliverables rather than just text, and attach those files to the email they send you.

Knowing which brain holds the answer is a question you shouldn't have to answer. Search now runs across every brain you have access to, with a routing step that narrows to the likely ones first rather than fanning out over all of them.

Each brain also maintains a generated overview — what it contains, what it's for — which is what routing reads to make that decision, and which you can read yourself to get oriented in a brain someone else built.

Procedural memory is only useful if it arrives before the agent acts, not when someone thinks to search for it. POST /v1/memories/trigger returns the lessons and procedures relevant to the work at hand, keyed off the entities in play — separate from ordinary semantic search, which now lives behind typed search groups.

Directives are filtered at capture time, so what comes back is what survived the keep/drop pass rather than everything ever written down.

Say what you want to happen and when, and chat writes the routine. "Email me a digest of the design brain every Monday" creates a scheduled routine; "when a Fathom call lands, pull the decisions into the product brain" creates an event-triggered one. Listing, editing, deleting, and running them on demand all work from the same conversation.

Routines run a skill against a brain, produce a deliverable, and email it to you as rendered HTML. Event triggers cover documents being added, artifacts being saved, and Fathom meetings landing, each with a condition gate so a routine doesn't fire on everything.

A skill is a reusable procedure your agents can execute — packaged, versioned, and stored as a real bundle rather than a prompt someone pasted into a doc. Author one in chat or from Claude Code with create_skill, share it into a brain, and anyone who can reach that brain can run it.

Skills stage into the code-execution sandbox by name, so chat can load the right one for the task instead of improvising. Built-in skills are preloaded for everyone.

Connect the GitHub App and MemHub reviews your pull requests, posting findings as inline review comments on the diff. Because the reviewer reads your team's brains, it flags the things a generic linter can't — the decision made three months ago that this PR quietly reverses.

Findings are ranked by user-felt impact rather than severity theatre, re-flagged findings are deduplicated across rounds, and fixed ones resolve themselves. Add the skip-review label to opt a PR out. Available on Scale and Enterprise.

Two connectors landed this release. Fathom installs over OAuth and ingests your call recordings into a brain via webhook, so decisions made on a call are searchable without someone writing them up afterwards. The GitHub App installs at the org level and brings repository activity in the same way.

You can also ingest a document straight from a public URL over REST — useful when the thing you want in a brain is a page rather than a file.

Notion connects over OAuth at the org level. An admin grants the specific pages the team should be able to draw on, and those pages become brain content — searchable alongside everything else, refreshed as they change rather than imported once and left to rot.

Grants are explicit, so connecting Notion doesn't mean handing over the whole workspace.

MemHub speaks MCP. Point Claude, Cursor, or Claude Code at your server URL and the agent can search your team's memory with search_memory, save what it learns with add_memory, and store artifacts with save_artifact — no copying context between tools.

Auth is handled at the transport level with OAuth discovery, so connecting is a browser round-trip rather than a pasted key. Connected apps are listed in settings and can be revoked from there.

Wiring a terminal agent to MemHub no longer means minting a key by hand. memhub login authenticates in the browser and hands the credentials back to the terminal, over a loopback redirect or the device flow when a browser isn't available.

Brains now live inside workspaces, each with its own members and overview page, so a team that works on several things at once can keep them apart. Every brain got a detail page with sharing, renaming, and settings in one place.

The app layout was rebuilt around this — a real sidebar with a single source of truth for what's highlighted, billing moved into the org selector, and personal and team content separated instead of interleaved.

Creating a brain used to mean filling in a form and then figuring out what to put in it. Describe what you want instead: the create flow proposes topics, shows you the facts and episodes behind each one before committing, and builds the brain from what you keep.