Changelog

• Ingestion reliability — fixed overlapping memory writes and database connection exhaustion during concurrent session capture and conversation imports, which could briefly make MemHub unavailable. Processing now queues safely, retries interrupted work, and limits background database use to leave capacity for everyday requests.
• Artifact browsing — agents can browse beyond the brain Index's first few items and page through an artifact group without guessing a search query. Results stay compact and match the Index's grouping.
• Routine outputs — when a routine's agent has already saved its deliverable, the routine reuses it instead of saving a second copy.
• Rule suggestions — session-based rule suggestions leave the writing to the coding agent that worked on the session, removing an extra model call whose draft was unused.
• Rulebook privacy — checks for personal email addresses and home-directory paths now cover nested trigger conditions and scope fields in session-generated rule suggestions, preventing those details from being copied into shared rules.

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:

1. Open Connected sources and use the settings cog on your GitHub connection.
2. Find Session insights on pull requests, review the visibility notice, and select the repositories you want to enable. Use the search field to find a repository.
3. Click Save.

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.

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.

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.

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.

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.

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.

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.