Two Kinds of Memory for Your CLI Agent

So you set up a memory layer for your local CLI agent. Now what? How do you actually get that memory in front of the agent so it does something useful?

I’m going to walk through what I did with mem0, but the shape of this applies to pretty much any memory layer. The first thing worth understanding is that CLI agents work with memory in two very different ways, and the difference matters.

The first way is text that’s always loaded. It gets injected into every session’s context automatically. No action needed on the agent’s part, it’s just there. This is your guaranteed data, the stuff that shows up at the start of every conversation.

The second way is semantic memory. For me that’s mem0 and the tooling I’ve built around it. This layer is accessed through an MCP server that exposes commands like recall and remember. It’s poll-based. The agent has to decide to call recall, because nothing gets auto-injected. The agent needs to be smart enough to say “I’m not sure about this, let me go look it up.”

Those are the two flavors. Let me break them down.

Layer 1A: The Shared Instructions File

For most CLI agents, this is a single markdown file that the harness auto-loads into every session. Claude Code reads CLAUDE.md. Gemini and Antigravity read GEMINI.md. And AGENTS.md has become the cross-tool convention, read by OpenCode, Antigravity, and Cursor alike. Same idea everywhere, just a different filename.

The one rule here: keep it minimal. Every line in this file is context you’re paying for on every single session. So don’t dump your whole knowledge base into it. The durable conventions, the project-specific facts, the things you only occasionally need? Those belong in your semantic layer, not here. This file is for the handful of rules that need to be loaded 100% of the time.

Layer 1B: Auto-Memory

Claude Code shipped a feature called auto-memory. It lives in ~/.claude/projects/, inside a subfolder that’s basically a slug of your project’s path on disk. In there you get a memory folder with a MEMORY.md file alongside the individual memory files.

MEMORY.md works like an index. It holds short pointers to the durable memories stored next to it, and the whole thing gets loaded every session. It’s still part of layer 1, the always-loaded kind.

Worth noting: this is a Claude Code thing. OpenCode and Antigravity don’t load or even know about these files. There’s no equivalent. Antigravity does have its own separate memory store that it syncs on its own, but it’s a different mechanism entirely, not a reader of Claude’s auto-memory.

Layer 2: The Semantic Layer

This is where it gets fun. I built a small MCP server in Go, a local binary that forwards requests to another server on my network. That server talks to two databases: Qdrant for the vectors, and Neo4j for the graph. The three functions I lean on most are recall, remember, and add_relation.

If MCP is new to you, the short version: it’s an open standard that lets your agent connect to external tools and data over a common protocol. Instead of N bespoke integrations, you run one MCP server per capability and the host discovers it. People call it “a USB-C port for AI,” which is annoying and also pretty accurate.

Wiring it up is just config. For Claude Code, it goes in ~/.claude.json under the top-level mcpServers.memory block. For OpenCode, it’s ~/.config/opencode/opencode.json under mcp.memory, with type: local and a command that runs the binary.

The Part People Forget

Here’s the step that ties it all together. Setting up the MCP server doesn’t do anything on its own. Remember, the semantic layer is poll-based. The agent won’t call recall unless it knows it should.

So you go back to layer 1, your always-loaded instructions, and you add a few lines telling the agent how and when to use the MCP server. Something like “before answering questions about this project, call recall with a relevant query” and “when the user tells you something worth keeping, call remember.” That instruction is small, it’s cheap, and it’s what turns a dormant memory store into a memory layer the agent actually reaches for.

That’s the whole architecture. Always-loaded text that’s guaranteed but expensive, and a semantic store that’s huge but only as good as the agent’s instinct to go check it. Get both layers talking and your agent stops forgetting who you are every morning.

Sources

mem0 — GitHub — the universal memory layer for AI agents that the post describes wiring up; 59.6k stars, Apache 2.0.
Model Context Protocol — Wikipedia — MCP as an open standard introduced by Anthropic (Nov 2024) for connecting AI systems to external tools and data sources.
Emma Roth, “Anthropic launches tool to connect AI systems directly to datasets” (The Verge, Nov 25, 2024) — news coverage of the MCP launch; confirms the “USB-C port for AI” framing and the standard-protocol pitch.
Jonathan Kemper, “Claude Code now remembers your fixes, your preferences, and your project quirks on its own” (The Decoder, Feb 27, 2026) — news coverage of the auto-memory feature; confirms the MEMORY.md per-project file and the ~/.claude/projects/ directory structure.
How Claude remembers your project — Claude Code Docs — official documentation for CLAUDE.md files and the auto-memory system.

I’d appreciate a follow. You can subscribe with your email below. The emails go out once a week, or you can find me on Mastodon at @[email protected].

Jun 30, 2026 AI Tools Agents Mcp Memory

Supacode

Native terminal coding agents command center. Run 50+ coding agents in parallel.

Jun 18, 2026 Programming Tools links agent automation code

Declutter your JavaScript & TypeScript projects

Project linter to find unused dependencies, exports and files

Jun 3, 2026 Programming Tools Dev links code javascript software engineering

Quarkdown | Markdown with superpowers

Quarkdown is a modern, open-source, Markdown-based typesetting system for creating papers, presentations, knowledge bases and static websites.

May 20, 2026 Writing Tools Markdown links open source

Pandoc vs MarkItDown: Two Tools, Two Eras

Pandoc has been the gold standard for document conversion for nearly two decades. But there’s a newer tool from Microsoft called MarkItDown, and while the names sound like they do similar things, they were built for completely different reasons.

Pandoc is a universal document converter designed for human publishing. It converts almost any format into almost any other format while preserving complex typography, citations, and formatting. MarkItDown is a specialized extraction tool designed for AI. It converts various files strictly into Markdown so that LLMs and RAG pipelines can read and process the text.

Same input files, very different goals.

Pandoc: The Universal Translator

Pandoc has been around since 2006, written in Haskell, and it operates on an Abstract Syntax Tree. It reads a document, builds a complex internal model of its structure, and then translates that structure into your desired output. We’re talking 40+ output formats here. PDF, Word, HTML, LaTeX, EPUB, you name it.

Where it really shines is academic and technical writing. It natively understands LaTeX math, footnotes, bibliographies, and cross-referencing. You can turn a Word doc into Markdown, edit it, and use Pandoc to turn it back into a perfectly formatted PDF. Two-way conversion that actually works.

You can also write custom filters in Lua or Python to programmatically alter documents during conversion. Want to automatically downgrade all your H2s to H3s? Pandoc has you covered.

MarkItDown: The LLM Feeder

MarkItDown was released by Microsoft in late 2024 to solve a very modern problem. LLMs need clean, structured text to “read” documents, but corporate data is locked inside messy formats like multi-tab Excel spreadsheets, image-heavy PowerPoints, and ZIP archives.

It’s a Python library first, CLI second. It drops into your scripts in a few lines of code, which makes it easy to wire up with LangChain, LlamaIndex, or raw API calls. The output is always Markdown. That’s it. No PDF generation, no Word docs, no EPUB. Just clean text that an AI can process.

The interesting trick is what it does with images and audio. Feed it a PDF with diagrams and MarkItDown can connect to an LLM like GPT-4o to look at the image and write a Markdown description of what it sees. It can also transcribe audio files. That’s a fundamentally different approach from Pandoc, which preserves images as files rather than describing them.

Quick Comparison

Feature	Pandoc	MarkItDown
Primary Goal	Universal document conversion	Document ingestion for AI
Output Formats	40+ (PDF, Word, HTML, LaTeX, etc.)	Only Markdown
Language	Haskell (standalone CLI)	Python (library-first)
Image Handling	Preserves and extracts image files	Uses OCR/LLM Vision to describe images as text
Complex Formatting	Citations, bibliographies, LaTeX math, custom filters	Basic structural support (headings, tables, slides)

So Which One Do You Want?

Pandoc if you’re writing a book, research paper, or blog and need polished output in multiple formats. If you need to maintain citations, complex formatting, or convert files out of Markdown into something else, Pandoc is your tool.

MarkItDown if you’re building an AI agent, chatbot, or search tool and need to extract text from a pile of PDFs, Excel files, and PowerPoints. If you only care about getting raw structured text and don’t care about the visual layout of the original document, MarkItDown is purpose-built for that.

They’re not competitors. Pandoc is for publishing. MarkItDown is for feeding AI. Pick the one that matches what you’re actually trying to do.

I’d appreciate a follow. You can subscribe with your email below. The emails go out once a week, or you can find me on Mastodon at @[email protected].

Apr 28, 2026 AI Tools Development

What Companies Are Actually Paying for Application Security

In the Application Security Testing (AST) market, Static Application Security Testing (SAST) and Software Composition Analysis (SCA) represent the two most critical pillars of preventative cyber defense.

So as a part of that, we should talk about the thing that people normally can’t or don’t talk about and that is cost. Vendors like to hide their pricing behind “contact sales” buttons, and buyers end up negotiating based on hard to find information.

So here’s an unofficial look at what companies are actually paying, pulled from a Deep Research report provided by Gemini. At the very end there is a list of resoruces where you can learn more about these subjects. However it is important to mention, there are not a lot of viable options for the home/hobby market.

What the Market Looks Like

Vendor	Average Mid-Market / SMB Spend (Annual)	Average Large Enterprise Spend (Annual)	Economic Dynamics and Negotiation Factors
Snyk	~$47,428	~$222,516	Costs scale rapidly with developer headcount. Highly susceptible to volume discounting. Total cost includes separate quoting for onboarding and services.
Black Duck (Coverity)	$60,000 – $120,000 (50-100 devs)	$150,000 – $300,000+ (150+ devs)	Full platform deployments (SAST + SCA) often range from $300k to $600k+. Volume discounts and custom enterprise agreements are typical. Premium support adds 20-30%.
Checkmarx	$35,000 – $75,000	$100,000 – $250,000+	Pricing is considered complex. Hidden costs include mandatory professional services, premium support, and infrastructure overhead, adding 15-35% to year-one totals.
Veracode	$40,000 – $80,000	$100,000 – $250,000+	Application-based pricing feels predictable until microservice architectures cause application counts to explode. Discounts are heavily available for SAST+DAST+SCA bundles.
SonarQube	$30,000 – $50,000 (up to 5M LOC)	$80,000 – $180,000 (5M - 20M+ LOC)	Highly predictable LOC model. However, self-managed deployments incur separate infrastructure and administrative overhead costs not reflected in the software license.
HCL AppScan	$50,000+	$100,000 – $500,000+	Unified platform pricing for large deployments can easily exceed $1M. Implementations often require months of setup and heavy professional service fees.

Official Licensing Models and Published Structures

Vendor / Platform	Primary Pricing Metric	Published Entry-Level / Standard Tier Pricing	Enterprise Pricing Status	Key Inclusions & Pricing Caveats
Snyk	Per Contributing Developer	Team Tier: ~$52–$98 per developer/month ($624–$1,176/year).	Custom / Unpublished	Includes Snyk Code (SAST) and Open Source (SCA). Enterprise plans drop per-seat costs at high volume but require minimum seat counts.
SonarQube	Lines of Code (LOC) Analyzed	Developer Edition: ~$15,000 for 1M LOC. Smaller tiers available (e.g., ~$2,500 for 100k LOC).	Annual Pricing; Talk to Sales	Prices scale strictly by the largest branch of private projects. Enterprise Edition adds legacy languages. Advanced Security is an add-on.
GitHub Advanced Security	Per Active Committer	$19/user/month (Secrets) + $30/user/month (Code) = $49/user/month.	Custom / Add-on to Enterprise ($21/user base)	GHAS is strictly an add-on to the GitHub Enterprise plan. Tied directly to commit activity within a 30-day window.
Mend.io	Per Contributing Developer	AppSec Platform: Up to $1,000 per developer/year.	Included in upper bound limit	Includes SAST, SCA, Renovate, and AI Inventory. No limits on LOC, scans, or applications. AI Premium is an extra $300/dev.
Checkmarx	Custom (Historically Per App or Node)	Team Plans: ~$1,188/year base. Enterprise base starts ~$6,850/year.	Custom / Unpublished	Highly modular pricing based on developer count, module selection (SAST, SCA, DAST), and deployment model.
Veracode	Per Application or Per Scan	Basic plans start at ~$15,000/year for up to 100 applications.	Custom / Unpublished	Pricing heavily depends on application count, scan frequency, and support levels. SCA alone starts around $12,000/year.
Black Duck (Coverity)	Per Team Member / Custom	Coverity SAST: $800–$1,500 per team member annually.	Custom / Unpublished	Pricing scales with user access. Often bundled. Perpetual licenses with 18-22% annual maintenance fees exist for legacy deployments.
Contrast Security	Custom (GiB hour / usage)	Essential tier: $119/mo. Advanced: $359/mo. Enterprise base ~$6,850/yr.	Custom / Unpublished	Pricing varies by package (AST vs. Contrast One managed service) and workload throughput.
HCL AppScan	Per Scan / Enterprise License	SaaS: ~$313 per scan (min 5 scans). Basic Codesweep: $29.99/scan.	Custom / Unpublished	Enterprise suite pricing is highly customized, often requiring significant upfront capital expenditure.

Feature Comparison

Feature / Capability	Snyk	Veracode	Black Duck	Checkmarx	Mend.io	GitHub (GHAS)	SonarQube	Endor Labs
Primary Strength	Developer Adoption & Speed	Enterprise Governance & Low FPs	License Compliance & Deep SAST	Unified ASPM & Repo Scanning	Automated Remediation	Native Ecosystem Integration	Code Quality & Baseline Security	Noise Reduction & Reachability
Reachability Analysis	Basic	No	No	No	Advanced	No	No	Full-Stack (95% reduction)
Automated AI Fixes	Yes (DeepCode)	Yes (Proprietary Data)	No	Yes (Limited IDE)	Yes	Yes (Copilot)	Yes (CodeFix)	Yes (Without upgrades)
Compilation Required	No	Yes (Binary)	Yes (Coverity)	No	No	No	No	No
Broad Language Support	High (14+)	Very High (100+)	High (22+)	High (35+)	Very High (200+)	Moderate	High (40)	Moderate
License Compliance	Moderate	Moderate	Enterprise-Grade	Moderate	Enterprise-Grade	Basic	Basic	Moderate

Learning

Apr 1, 2026 DevOps Tools security Devsecops

Just: The Command Runner

If you’ve ever used make to run commands, it works, but you’re using a build system as a command runner. Just is a dedicated command runner that does exactly what you want and doesn’t come with all the baggage.

Created by Casey Rodarmor about a decade ago (it turns 10 this June), Just is written in Rust and laser-focused on being a really good command runner. That’s it; just a clean way to define and run commands.

Why I Use It

On a lot of my projects, I use Just in conjunction with Mise. Mise does a fine job as a task runner, but when I want something more expressive for command orchestration, Just is what I reach for.

For example, I’ve got a lot of really long Python commands these days. I’m injecting environment variables at runtime, calling Poetry, then running Python with specific arguments. There’s a ton of boilerplate you have to type out every time. I don’t want to remember all of that, and I definitely don’t want to go digging through my shell history or copy-pasting from a README.

Just simplifies that. Define it once in a justfile, and now your common commands are now just <recipe>.

Modules Changed the Game

Something I started using recently is Just’s module system, which with it you can create separate .just files and have your main justfile import them as submodules. This lets you group related commands naturally.

So instead of flat recipes like:

just test-cover
just test-unit
just test-integration

You can organize them into modules:

just test cover
just test unit
just test integration

It’s a small change, but it makes your command surface feel a lot more intuitive, especially as your project grows and you accumulate dozens of commands.

Getting Started

If you want to dig deeper, Casey wrote a great walkthrough called Tour de Just that covers the highlights. The official documentation is great too.

Just is commercially friendly, widely packaged, and easy to install on pretty much any platform. If you find it useful, you should consider sponsoring Casey on GitHub. Open source maintainers deserve support for tools we rely on daily.

Mar 22, 2026 Tools Development Just Command-runner

I'm Just Going to Use Zed

I’ve been thinking about my editor setup and I wanted to work through the costs out loud. This post is mainly for me, but maybe it helps you too.

Here’s where I landed: I’m canceling(ed) JetBrains and Cursor, and just using Zed.

I know that might sound crazy. JetBrains All Products has been my go-to for a while now, and Cursor was interesting for a bit, but turns out all I needed was speed and cheap.

The Cost Breakdown

Editor	Monthly Cost	Yearly Cost
Zed Pro	$10.00	$120.00
Cursor Pro	$20.00	$240.00 ($192 if billed annually)
JetBrains All Products	~$14.92	$179.00

Zed Pro at $10/month is the cheapest option by a decent margin. That’s $120 a year versus $179 for JetBrains or up to $192 for Cursor. Not a huge difference money, but it adds up.

Zed Is Enough

My primary way of working these days is Zed plus CLI-based tools. I use Claude Code in the terminal (Mostly Ghostty) alongside the IDE, and that combination handles everything. The editor itself is fast, the AI integration is solid.

I already canceled Cursor. It’s a good product, but not at double what Zed costs. Maybe I’ll go back and try it again at some point, but right now there’s no reason to do that.

Sometimes the right move is just picking what works and not overthinking it.

Mar 18, 2026 Tools Development Zed

Voice-to-Text in 2026: The Tools and Models Worth Knowing About

As natural language becomes a bigger part of how we build software, it’s worth looking at the state of transcription models. What’s the best way to get voice to text right now?

For a lot of people, talking to your computer is faster than typing. You can stream-of-thought your way through an idea, prompt your tools, and get things moving without your fingers being the bottleneck. If you haven’t tried it yet, it will change how you work with your machine. I’m not exaggerating.

The Tools

Here’s what people are actually using for desktop voice-to-text:

Willow Voice — Popular choice, lots of people swear by it
SuperWhisper — My current pick
Wispr Flow — Another well-regarded option
Voice Ink — Worth a look?
Aiko — From an Open Source dev, Sindre Sorhus
MacWhisper — Solid Mac-native option

I’ve tried several of these, and the biggest pain point for people is going to be that many require monthly subscriptions. I’ve been happy with SuperWhisper and it is worth mentioning they still have a pay for it once (Lifetime) option, so you don’t get locked into monthly payments forever. That said, Willow Voice and Wispr Flow both have strong followings.

The Models Behind the Magic

Most of these tools started with OpenAI’s Whisper, the voice model released and open-sourced back in 2022. With Whisper, you could run solid transcription locally on your own hardware.

But we’re a few years past that now, and there are some more models to choose from. Here is a summary table of the current state of the transcription models.

Model	Company	Released	Local Run?	Used in Desktop Tools?	Best For
Whisper Large-v3	OpenAI	Nov 2023	Yes	Yes (The Standard)	Multilingual accuracy (99+ langs)
Whisper v3 Turbo	OpenAI	Oct 2024	Yes	Yes (Fast Settings)	Best speed-to-accuracy ratio for local use
Nova-3	Deepgram	Apr 2025	Self-Host	Limited (API-based)	Real-time agents; handling messy background noise
Parakeet TDT 1.1B	NVIDIA	May 2025	Yes	Developer-focused / CLI	Ultra-low latency; significantly faster than Whisper
SenseVoice-Small	Alibaba	July 2024	Yes	Emerging (Fringe)	High-precision Mandarin/English and emotion detection
Canary-1B	NVIDIA	Oct 2025	Yes	Developer-focused	Beating Whisper on technical jargon & punctuation
Voxtral Mini V2	Mistral	Feb 2026	Yes	Yes (Privacy apps)	High-speed local transcription on low-VRAM devices
Granite Speech 3.3	IBM	Jan 2026	Yes	No (Enterprise focus)	Reliable technical ASR with an Apache 2.0 license
Scribe v2	ElevenLabs	Jan 2026	No	Via API	Extremely lifelike punctuation and speaker labels

---

We’re at an interesting inflection point. You can articulate your thoughts faster by speaking than typing, its becoming a real productivity gain. It’s not just an accessabiltiy aid anymore. People who can type well enough are using these tools on a daily basis.

That’s all for now!

Mar 17, 2026 Productivity AI Tools Voice

I got tired of plaintext .env files, so I built LSM. lsm exec will inject secrets at runtime so they never touch the filesystem. Doppler’s idea, minus the monthly bill.

How are you managing local secrets?

Mar 14, 2026 Programming Tools security