With every company struggling to cap AI cost budgets, as a developer I found it equally hard to keep track of my own API usage costs when coding with Cursor, Claude Code, or local scripts.

So I built AIMeter — an ultra-fast, local-first LLM API cost & token tracker for macOS. It transparently monitors your spend in a native menu bar widget and dashboard with zero latency overhead, keeping your prompts and keys 100% #private.

Open-source and installable in seconds via #DMG or #Homebrew!

GitHub: https://github.com/smriti-memcore/aimeter

We just released the v1.1 specification for the Agent Memory Protocol (AMP).

When we launched v1.0, the goal was simple: standardize how LLMs talk to memory backends using Model Context Protocol (MCP) tools. But putting memory tools directly in the LLM's loop created a few major issues:

• LLMs shouldn't be running background maintenance tasks like memory consolidation or fetching database stats. That wastes tokens and adds latency.
• Host applications (harnesses) often need to inject memories into the prompt before the agent runs, which is awkward if memory only exists as stdio tool calls.
• Storing metadata was a mess because every backend used different keys, breaking cross-engine compatibility.

AMP v1.1 addresses these bottlenecks by shifting from "just MCP tools" to a standalone, service-first architecture.

Here is what changes:

1. Standalone Service boundary: The protocol now defines first-class HTTP REST and gRPC API contracts. The host application handles session management, background tasks, and context injection, while presenting a clean, tool-only MCP adapter to the agent.
2. Cognitive vs. Autonomic separation: LLMs only see cognitive tools (encode, recall, forget). Background maintenance verbs (consolidate, pin, stats) are handled out-of-band by the harness.
3. Multi-dimensional scoping: Scoping is no longer flat. You can partition memory by organization, application, workspace, user, and agent. This makes it trivial to support collaborative agents and shared team spaces.
4. Memory Exchange Format (MXF): An open, NDJSON-based format to easily export or import memory logs, making it simple to migrate between backends (Zep, Mem0, smriti-memcore, etc.) without vendor lock-in.
5. Standardized Metadata Vocabulary: Common namespaces for things like TTL, confidence scores, entities, and lineage links, so your query filters remain uniform.

What is coming next in v1.2 (Draft in progress)

We are currently drafting the v1.2 specification to introduce in-place memory mutations (amp.update), bulk ingestion (amp.batch_encode), and structured metadata filtering. You can check the active design branches on GitHub if you'd like to participate in the spec.

You can read the full spec, migration guide, and inspect the updated JSON Schemas here: https://github.com/smriti-memcore/amp

Let me know what you think. If you are building memory backends or developer frameworks, I'd love to hear how this fits into your stack.

Hey everyone,

One of the biggest headaches with AI agents right now is memory fragmentation. Every backend (Mem0, smriti-memcore, custom vector DBs, etc.) has its own APIs, schemas, and quirks. Switching backends or trying to make agents portable is painful.
So I’m excited to share AMP — Agent Memory Protocol: https://github.com/smriti-memcore/amp

An open specification that defines a clean, standardized interface for persistent memory in MCP-compatible agent systems.

The Six Core Verbs
• amp.encode — Store new memories
• amp.recall — Retrieve relevant memories
• amp.forget — Permanently delete
• amp.consolidate — Trigger backend reorganization / summarization
• amp.pin — Mark important memories as permanent
• amp.stats — Get backend health & usage stats

It comes with Core (basic) and Full conformance levels, a full JSON schema, compliance test suite, minimal example, and a production reference implementation (pip install amp-server that wraps smriti-memcore).

Why this matters:
Write your agent once against AMP → it can work with any compliant memory backend without code changes. True interoperability for the memory layer.
Repo: https://github.com/smriti-memcore/amp
Quick start is super simple — you can run the minimal example in seconds with zero dependencies.

Would love feedback from the community:
• Does this solve a real pain point for you?
• Which backends would you want AMP wrappers for first? (Chroma, Pinecone, pgvector, Zep, etc.)
• Any missing verbs or features?

Looking forward to PRs and implementations!
(Independent open spec — MIT licensed, not affiliated with Anthropic/MCP)