Mastra Code - The AI coding agent that never compacts

Paul from Mastra here, excited to launch Mastra Code 🎉

Mastra Code is a CLI-based coding agent built on the observational memory feature we shipped earlier this month. Our team uses it as their daily coding driver, and we think you’ll love it.

What problem does Mastra Code solve?

A lot of coding agents feel great at first, until the context window fills up. When this happens, the agent uses compaction to summarize past conversations, often dropping important details and forcing you to repeat work, re-explain context, or double-check what its remembered, which can become really frustrating.

Mastra Code is different. It's powered by our state-of-the-art observational memory, which watches your conversations, generates observations, and reflects on them to compress context without losing important information.

The result is simple: long-running coding sessions that remember what matters so you can build faster, merge sooner, and ship more.

Get started

Install mastracode globally with your package manager of choice:

npm install -g mastracode

If you prefer not to install packages globally, you can use npx:

npx mastracode

What it's like to use

Mastra Code runs directly in your terminal, with no browser or IDE plugin required. With most coding agents, you spend time managing context windows, splitting work across threads, or saving notes before compaction hits. With Mastra Code, there is no compaction pause and no noticeable degradation, even in long-running sessions.

No compaction! Even with 1M context window compaction took like 3 minutes. With Mastra Code I don't notice any degradation, I don't curse into the air, I stopped yelling COMPACTION, and my mental health is better for it. — Abhi Aiyer

You can throw anything at it: planning, brainstorming, web or code research, writing features, and fixing bugs. Over time, memory fades into the background so you can focus on building.

I don't worry about the conversation length or multiple threads for anything. I just keep rolling and it keeps going. — Daniel Lew

After a few days, you realize you're no longer tracking context windows or restructuring work to avoid compaction. Observational memory quietly remembers what matters as sessions grow. Once you experience that, it is hard to go back.

We'd love your feedback. Drop questions below and we will be here answering all day.

wow this is just AWESOME!

Never compacts’ isn’t a feature, it’s a mentality. Most agents lose the plot like a junior pushing to prod on Friday at 5pm. This isn’t about cute summaries, it’s about decision-grade memory. If you truly preserve those rare constraints from three hours ago, that’s a real shift. Everything else is just context theater.

"Never compacts" is the right framing — the real failure mode is mid-session context amnesia, not the obvious stuff. The hard part is that standard summarizers preserve what's recent or frequent, but the detail that derails a session is usually the rare constraint mentioned once: a deprecated API, a specific architectural decision made three hours ago. Does the observational memory layer use explicit signals (test failures, user corrections) to weight those rare-but-critical details, or is importance inference more heuristic?

We use MastraCode internally to build Superset and it’s 🔥

The team ships lightning quick and has great taste!

This is really interesting the “no compaction” part hits hard, that’s a real pain

Curious — with long-running sessions and persistent memory, how are you thinking about security around stored context?

Like preventing sensitive data leaks or unintended access over time?

The observational memory approach is really compelling. Context compaction has been my biggest frustration with long coding sessions — you lose that one architectural decision from 2 hours ago and suddenly the agent is working against your own codebase.

Question: how does the memory layer handle conflicting information? E.g., if early in a session you say "use REST" but later switch to "actually, let's go with GraphQL" — does it pick up on the correction or does the older observation persist?

Congrats on the launch!

I have been using MastraCode daily for many weeks now!

Things I love about using it:

1. Never hitting the break in momentum from compaction

2. Long single sessions were an anti pattern but now I do them all the time and my agent recalls nicely

3. You can build your own version of it using Mastra OSS Harness!

Congratulations on the new launch! The more memory, the more tokens the service consumes. How are you addressing this issue?