Every serious AI workflow eventually runs into the same failure.

The agent does useful work in one session. It learns the shape of the project. It
figures out which assumptions were wrong. It follows a correction, makes a
decision, and gets closer to the real work.

Then the session changes.

The next run starts too cold. Old context comes back without the correction that
changed it. The agent asks for the same setup again. It repeats an assumption
that was already fixed yesterday. You end up managing the memory of the work
instead of moving the work forward.

That is the problem Pith is built for.

Pith gives AI agents durable project memory they can trust when facts change.

It is not trying to make an agent remember everything. That would be the wrong
goal. Real projects are messy. Facts change. Decisions get reversed. A note that
was useful last week can become stale after a release, a migration, a new
customer constraint, or one correction from the human operator.

The harder problem is not recall. The harder problem is knowing which memory is
still useful.

Why Longer Context Is Not Enough

Longer context helps, but it does not solve continuity by itself.

A long prompt can carry more text into a single run. It cannot automatically
decide which prior facts survived a correction, which decision is now superseded,
or which evidence should come back when the project resumes three days later.

Developers working with agents already feel this. The friction shows up as small
taxes:

• repeating project background that the agent should already know;
• re-explaining decisions that were already made;
• correcting stale assumptions that were already corrected;
• losing the reason behind a prior choice;
• restarting from a cold state after every meaningful break.

Those taxes compound. The more serious the workflow, the more expensive the
memory gap becomes.

If an agent is helping with a toy task, forgetting is annoying. If an agent is
helping with a codebase, a release, a customer workflow, or a long-running
research path, forgetting becomes operational drag.

What Pith Does

Pith is a local memory layer for AI agents that need durable project context.

It keeps useful decisions, corrections, and project facts available across
long-running work so agents do not have to restart from zero every session.

The developer preview is built for builders experimenting with agent workflows,
local-first memory, MCP-compatible clients, and AI coding tools. The current
macOS preview supports a public install path, a local API, and client setup paths
for different levels of automation.

In the latest public release, Pith v1.0.3, the developer preview package refreshes
client setup language and local API tooling. Claude Cowork and Codex are presented
as the more automated setup paths. Claude Desktop, Claude Code, VS Code, and
Cursor remain supported with clearer boundaries where manual steps, model tool
choice, or verification checks may still apply.

That distinction matters. A developer preview should tell you what is automated
and what is still rough. If a memory layer is supposed to help agents handle real
work, the setup path cannot pretend every client behaves the same way.

The Memory Problem Is Really a Trust Problem

Most AI memory discussions collapse into storage.

Where do we put the notes? How do we search them? Which embedding model do we
use? How large is the context window?

Those questions matter, but they are not the full problem.

The real question is whether the agent can trust the memory it retrieves.

If a user corrected a fact yesterday, old memory should not quietly beat the
correction today. If a decision was reversed, the agent should not revive the old
decision just because it is semantically similar. If evidence exists for why a
claim matters, the system should make that evidence inspectable instead of
turning memory into vibes.

This is where Pith is opinionated.

The product is aimed at governed project memory: context that carries forward,
but also has to survive changed facts, contradictions, and corrections. That is
the difference between generic recall and memory that can support real work.

What Is Live Now

The Pith developer preview is public for macOS builders.

Install:

https://pith.run/install

Release:

https://github.com/pithrun/pith-core/releases/tag/v1.0.3

Benchmark evidence:

https://pith.run/benchmarks

The benchmark page publishes scoped launch evidence for named memory benchmark
lanes, with evidence files and caveats. Treat that proof the way it is intended:
as inspectable evidence for specific lanes, not a universal claim that one memory
system wins every workload.

That boundary is deliberate. AI memory is not one problem. Different systems can
look strong under different workloads, models, and evaluation setups. Pith should
earn trust by making its claims narrow enough to inspect.

Who Should Try It

Pith is not for casual traffic yet.

The useful early users are builders with real agent workflows: people who have
felt the cost of restarting context, re-explaining decisions, or cleaning up
stale assumptions across repeated sessions.

You are probably a good fit if:

• you use agents for long-running coding, research, operations, or product work;
• you already have repeated project context that gets lost between sessions;
• you want local-first memory rather than a black-box hosted layer;
• you care about evidence and caveats more than broad "best memory" claims;
• you are willing to tolerate developer-preview rough edges in exchange for direct learning and fast iteration.

You are probably not the right fit if you want a polished consumer app, a managed
team product, or a no-rough-edges onboarding path today.

That will come later if the developer preview proves the core workflow.

The Bet

The bet behind Pith is simple:

Agents that work on real projects need memory that behaves more like operational
context and less like a pile of retrieved notes.

They need to remember what changed. They need to carry corrections forward. They
need to know when old context has become risky. They need enough evidence around
memory that a developer can inspect why the agent is acting on it.

That is not solved by a bigger prompt alone.

It is a product problem, a systems problem, and a trust problem.

Pith is the developer preview of that bet.

If you are building agents and want memory that survives real work, try it here:

https://pith.run/install