New features, improvements, and fixes across MemHub and the Memory API.
You can now create a MemHub account and sign in with an email address and password alongside Google. Teams can invite colleagues who prefer to use a password, with new accounts confirmed by a code sent to their email address.
Invitation links prefill the invited address and take new teammates straight to signup. The invitation email explains which address to use and how to confirm it, so you can join with the account your team invited.
Engineering teams can now explore pull request delivery alongside coding-session activity in Sessions → Summary. PR stats count pull requests merged in the selected period, while effort includes all recorded work from their linked sessions, including work done before that period.
Hover over a time point to inspect the Summary charts together, or click to pin it while you compare. Separate coverage for turns and tokens shows which PRs have measurements, and the PR list lets you inspect the measured or unavailable subset.
For pull requests that have no linked session, open the review sheet to link contributing sessions or dismiss the PR. Dismissed pull requests remain available in the Dismissed view if you want to link them later.
memory:read key, or delete your own sessions with a memory:write key using the conversation or harness session ID./memhub:rules-from-sessions reuses previously processed session work and handles batches more efficiently, reducing the wait for suggestions.A pull request shows what changed. MemHub now brings the contributing coding sessions into GitHub, giving engineering teams more context for reviewing AI-assisted work.
The session insights comment brings together decisions, lessons, team rules that fired, and agent effort, with coverage showing which sessions contributed to the report.
To enable it, sign in to Studio as an organization admin:
Anyone who can read an enabled repository can read its session insights comment. On a public repository, that means everyone. To stop publishing for a repository, clear its checkbox and save again.
read_memory. For long artifacts, they can browse an outline and read individual sections instead of loading the whole document./memhub:link-pr to link a PR manually./memhub:find-contributing-sessions when several sessions contributed to the same PR.Every team has rules its agents keep breaking: never force-push, always run the migration check, leave the generated client alone. Rulebook is where those live. A rule is written once, filed in a rulebook, and reaches every agent session through the coding-agent hooks — so the convention shows up in the work rather than in a document nobody opens.
A rulebook is the unit of policy, and its membership is its scope. That separates who is bound by a rule from who can read a brain, so an org-wide standard and one team's local convention are the same kind of object with different audiences. Anyone added to one is told, and given a way out.
Rules have a life. They are proposed, activated, paused, dismissed, retired, or superseded by a newer rule that names exactly which one it replaces — so the list stays the rules you actually follow, not an archive of everything anyone ever suggested.
Fire history is the half that makes it honest. Every fire links back to the session and the message where it happened, so you can see which rules earn their place and which are just noise. Filter to Applies to me and you get the answer an engineer actually wants: what is enforced on me, and what has it done.
RULEBOOK_OVERRIDE='<why>' is the deliberate way past it. Only a rulebook or org admin can arm one, because a gate stops every teammate's agent./memhub:rules-from-sessions proposes rules from what your team already does: it reads the repo's CLAUDE.md and your Claude Code, Codex, and Cursor transcripts, replays every candidate through the real hook, and states each proposal's origin, its cost, and what changes with it on. Survivors are filed as proposed; nothing is activated for you.write_text(), or a sed -i is matched the same way a direct edit is.given conditions, path scope, and fixtures that verify it fires where you meant it to./memhub:create-rule proves a new rule actually fires before filing it, and checks it against the rules already in the book, so a duplicate or a contradiction is caught at authoring time.Error executing tool.X-Org-Id resolves the caller's org instead of silently serving no rules to installed hooks.RULEBOOK_OVERRIDE is recognised at the start of the blocked command, so the documented escape hatch works where you actually type it.Lanes could already lay a week of agent work out over time. It can now be
interrogated. ⌘ + scroll zooms the track and dragging pans it, so the same view
goes from a week at a glance down to what happened inside a single hour, without
changing filters or leaving the page.
Hovering a session splits its elapsed time into run and wait — wait being the gaps between spans, the idle that agent hours deliberately exclude. That is the difference between a session that took four hours and one that worked for four hours, and until now it was invisible.
Clicking an engineer's avatar opens a sheet for that person over the current window: occupancy, average and peak concurrency, sessions, turns, agent hours, tokens, and cache read rate. If you are trying to work out how your team actually uses agents — where the waiting goes, who runs work in parallel — that is the question Lanes now answers.
The figures stay honest about their own limits. When the window holds more sessions than the pool can draw, or turns and tokens cover only part of it, the footer says so instead of quietly showing you a smaller number.
active_seconds is an uncapped aggregate, so a long session over the span payload cap no longer reports one agent-hour figure in List and a larger one in Insights./studio/brains/{id} instead of the removed /cbs/{id} route./studio/sources no longer crashes when an early return changes the hook count after a connect attempt.Usage digests turn the questions you'd otherwise ask ad hoc into something that arrives on its own. Each one carries your own activity and, if you're an admin, the team's — sessions, turns, tokens, and the brains being read — measured against the previous period so a change reads as a change.
Drop-off signals call out the people and brains that went quiet, which is the part you'd never think to go looking for.
Settings → Notifications is where you own it: turn digests on or off, choose daily, weekly, or monthly, include the team section when you're an admin, and send yourself a test digest before committing anyone else to it. Unsubscribing remembers your cadence and channels, so coming back doesn't mean setting it up again.
Sessions has been redesigned around the fact that there's no single right way to look at a week of agent work. The new interface carries three views — List, Lanes, and Summary — and you move between them without losing your place or re-asking your question.
They share one set of controls. Filter the work down once and every view follows. Change the time grain and the charts re-bucket to match. Group by what you're actually asking about, and the rollup regroups with it.
List is the feed of individual runs. Lanes lays activity out over time. Summary rolls the same work up into totals.
@MemHub dm <teammate> still sends immediately.add_directive lets a client author a directive outright instead of waiting for extraction to notice a rule, and task-start recall can serve procedure memories before a task begins.last_synced_at, making shorter refresh cadences affordable when nothing has changed.5000+ facts rather than presenting a truncated enumeration as an exact count.add_memory, team message ingest, and imports stamp event_date where available, so more sessions become measurable instead of showing turns with no tokens or agent time.conv_id read would otherwise return an empty page from personal LTM.token to HubSpot introspection instead of access_token, fixing installs that failed as missing_hub_id.(unnamed) or None./settings/export step, and the dead email link that pointed at it is gone.SLACK_SIGNING_SECRET is unset, so Studio never shows a button whose click can't be verified.Sessions is the record of how your team's agents actually work. Every run in one feed, a turn-by-turn transcript for any of them, and Insights rolled up by engineer.
Each run shows who ran it, how long it took, the tools it called, the tokens it spent, and the memory it read. The questions the agent stopped to ask show up as decisions with the answer attached, not as another tool call. So you can tell whose process is working and where token spend is going to work already done. Understand whether an engineer is getting genuinely proficient with agents or just running more of them.
Linear used to be a personal connection: a routine that filed an issue filed it as the person who created the routine, and it reached whatever that person could reach. An admin now installs Linear once for the organization and grants access team by team, so an unattended routine acts as the org's MemHub app — scoped to the teams you granted it, and attributable to the automation rather than borrowed from someone's account.
Linear webhook events are supported too, so a routine can run on the issue lifecycle — an issue created, a status changed — or on a new comment, instead of waiting for its next scheduled tick. Personal Linear connections still work exactly as they did.
staging/main commit history, pull requests, and repo files.@MemHub dm <teammate> … answers under the recipient's brain grants, and their answer goes to them alone — it's never echoed back to whoever asked. It sends without a confirmation step.add_memory captures, so it lists tasks someone actually started rather than empty imported rows.cb_id scope for facts, episodes, and artifacts instead of failing validation before the handler runs.last_synced_at, so the scheduler stops immediately re-importing data it just fetched.recall_directives reads the agent brain partition.save_result and save_to_agent_brain can write to a brain created earlier in the same turn.cryptography is updated to 50.0.0 for CVE-2026-69247. Our usage never reached the vulnerable PKCS#7 path, but the patched version now ships.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.
/docs, including a full personal-access-key API reference./changelog, backfilled to April.C on Brains, Routines, or Skills to create one.recall_directives takes a session_id and holds back directives that same session just wrote, so an agent stops rediscovering its own output.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.
send_email sends you an email from a conversation.list_skills and get_skill are available in chat, so the agent stops guessing skill names.blob: images); attachment filenames no longer print twice under their own thumbnail.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.
refresh_brain_overview regenerates a brain's overview on demand.run_kind.get_skill_file downloads a shared skill's bundle files.?include=run on the conversations list returns chat-run status.folder_id filter on the team brain list (eq.<uuid> / is.null).member_limit.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.
GET /v2/cb-activity and documented in OpenAPI./v1/team/skills./v1/developer.search_brains routes across brains over manifest embeddings.search_all_brains searches items across every brain you can reach.get_brain_overview reads a brain's generated overview.delete_skill, plus a refresh mode on add_skill_to_brain.GET /mem-manager/usage/summary, and self-serve management for the API subscription.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.
search_brains, search_all_brains, and get_brain_overview.delete_skill and a refresh mode on add_skill_to_brain.notion_node.path binds as ltree again, fixing an asyncpg type mismatch.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.
create_skill authors a skill from chat or Claude Code.list_skills and get_skill.recall_directives for team-stack directive recall.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.
list_orgs and an org_id argument across the surface.import_conversation brings a Claude Code conversation in wholesale.delete_artifact, artifact tags, and lineage/diff queries.search_memory now reaches the documents substrate.ARRAY so tag-filtered search works.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.
add_memory routes facts and episodes into a specific brain.parent_id, plus get_artifact lineage.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.
search_memory.save_artifact and add_memory write tools, plus a Claude Code turn-save hook.amount_total and currency, and has_billing_account is exposed for the trial-to-paid upgrade path.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.
list_workspaces.derived_from relationships, so a version chain can't be corrupted by a later edit.plan_id syncs from the Stripe price on subscription.updated.