AI coding agents are getting better at writing code, but there is another problem that becomes increasingly obvious the longer you use them: they forget.

Start a new session and you may have to explain the project structure again. Tell the agent how your tests are supposed to run, which coding conventions the team follows, or why a particular architectural decision was made, and there is no guarantee that the next session will remember any of it.

SpaceXAI is now addressing that problem in Grok Build. The company has added persistent memory that allows Grok Build to carry project conventions, decisions, and other useful facts from one session into the next.

The feature was announced on September 16 and is now generally available as part of Grok Build 1.0.34.

Grok Build can now remember how you work

Grok Build’s new memory system is designed around the idea that an AI coding agent should not have to start from zero every time a session begins.

As you work, Grok Build reviews completed turns in the background and records information that could remain useful later. That can include coding conventions, decisions made during development, project-specific facts, and details about how certain parts of a codebase work.

The important part is that this isn’t simply a giant transcript of everything you have ever told Grok.

SpaceXAI says the memory system deliberately focuses on durable information that is likely to matter in future sessions. Temporary task state, tentative conclusions, secrets, and information that is already adequately documented in the repository are left out.

That distinction matters. A coding agent remembering every passing comment would quickly become just as problematic as one that remembers nothing.

Instead, Grok Build is trying to create a lightweight project knowledge base that evolves as you work.

The memory is stored as Markdown files

Grok Build’s approach is particularly interesting because its memories are stored as Markdown files rather than being hidden entirely inside the AI system.

Each project gets its own workspace memory, while a separate global memory can hold preferences that apply across projects.

The system organizes information into topic files. For example, a project might have a testing.md file explaining how the test suite works and a code-style.md file containing coding conventions.

There is also a MEMORY.md file for broader information.

That makes the system much easier to understand than an opaque memory database. Developers can see what Grok Build has decided is worth remembering and inspect the resulting notes.

Grok Build also introduces a /memory command that opens a read-only browser for the memory files. The browser groups memories by scope and provides a preview of the selected file.

There is also a /dream command, which organizes recent observations into topic files. SpaceXAI says the process can also run periodically in the background.

It learns from completed sessions

The memory system operates after a turn has finished rather than interrupting the coding session.

Once a turn is complete, Grok Build reviews what happened and captures information that appears durable. SpaceXAI says this capture process runs in the background and does not block the current session.

That means something as simple as correcting Grok Build’s assumptions about a project’s test command can become useful later.

In SpaceXAI’s example, Grok initially tries cargo test, which fails because the project’s integration tests require a separate database setup. The developer explains that the correct command is just test, which starts the test database first.

Grok Build records that information in a testing topic. When the developer later asks it to modify the code and run the tests, Grok recalls the topic and uses just test instead.

The example is mundane, but that’s exactly where persistent memory can become useful. Developers don’t necessarily need an AI agent to remember huge architectural documents. Remembering small, recurring details can eliminate a surprising amount of repetitive prompting.

Project memory and global memory are separate

Grok Build also separates information that belongs to a particular project from preferences that should apply more broadly.

Project-specific knowledge stays within that project’s workspace. Global memory can contain preferences that apply across projects.

That separation should make the feature more useful for developers who work across multiple repositories without constantly mixing assumptions from one project into another.

SpaceXAI also says that instructions in the current conversation take precedence over information stored in memory.

That’s an important safeguard. If a developer tells Grok Build to do something differently in the current session, an old memory should not override the new instruction.

Memory is available in new Grok Build sessions

The feature is available now, but existing sessions don’t simply get retroactively transformed into memory-enabled sessions.

SpaceXAI says memory applies to new sessions. Developers can run /new or start a fresh grok session, after which notes begin being captured following the first completed turn.

The feature is part of Grok Build 1.0.34, which SpaceXAI’s changelog lists as a September 16 release. The same release also includes a fix for Markdown headings receiving theme colors correctly.

Grok Build itself has been expanding rapidly since its introduction. SpaceXAI brought Build to the web and mobile in August, making the coding and creation environment available beyond the original command-line workflow.

Memory is a natural next step for an agent intended to handle longer-running projects.

Why this matters for AI coding agents

Persistent memory is becoming increasingly important as AI coding tools move away from the idea of a chatbot that simply answers individual programming questions.

A serious coding agent may work on the same repository for days or weeks. It needs to understand not only what the code does, but how the developers expect the project to be maintained.

That’s where small pieces of accumulated context become valuable.

A developer shouldn’t have to repeatedly explain that a particular script must be used instead of a standard command, that a service intentionally lives in a particular directory, or that the team follows a specific pattern for pull requests.

Grok Build’s memory system is essentially an attempt to turn those repeated conversations into persistent project knowledge.

It also gives SpaceXAI an interesting advantage in how the feature is presented. Because the memories are stored as Markdown and exposed through /memory, developers have a visible representation of what the agent has retained rather than having to blindly trust that some invisible memory system is doing the right thing.

Of course, persistent memory also means developers will want to pay attention to what gets retained. SpaceXAI says the system intentionally excludes secrets and temporary information, but memory is still another layer of project context that needs to be kept accurate. A stale convention can be just as inconvenient as a forgotten one.

For now, though, the goal is straightforward: Grok Build should become less forgetful every time you use it.

And for an AI coding agent expected to work across multiple sessions, that may be one of the more important upgrades it has received so far.