Pricing a developer tool is one of the hardest decisions you make as a founder. Get it wrong and you either scare people away or leave money on the table. We spent weeks looking at how other tools in the AI agent space charge, and the patterns fell into three camps:
Per-seat pricing. $20-40 per user per month. Common in team tools like Linear, Notion, and most project management software. The problem: it penalises collaboration. Adding a team member costs money even if they barely use the tool. Studios and agencies with 10+ developers face bills that don't reflect actual usage.
Tiered subscriptions. Free, Pro, Enterprise. Each tier unlocks features or raises limits. The problem: you're always either paying for capacity you don't use or hitting a ceiling that forces an upgrade. The tiers are designed around the vendor's revenue goals, not around how developers actually work.
Usage-based pricing. Pay for what you consume. Common in infrastructure (AWS, Stripe, Twilio). The problem: unpredictable bills. A developer who doesn't monitor usage can get a surprise invoice. And for AI tools specifically, usage-based often means paying per token or per API call, which discourages the agent from querying context freely.
None of these felt right for what Minolith does. So we designed a hybrid.
The Minolith Pricing Model
$5/month base. This includes 500 credits and unlimited projects. Every account pays this. It covers the infrastructure cost of hosting your data, running the MCP server, and maintaining the API.
Credits for writes only. Creating a context entry, publishing a changelog entry, uploading a feedback item, defining an agent, creating a task. These are the actions that add data to the system. Each costs 1-5 credits depending on the service.
Reads are always free. Querying context, loading the bootstrap response, checking the team feed, downloading a styleguide asset, listing tasks. These cost nothing. Zero credits. Unlimited.
Context is entirely free. Every context operation costs zero credits. Storing rules, querying decisions, filtering warnings by tag. The core memory service that anchors the entire platform has no credit cost at all.
1 credit = $0.01 USD. Simple maths. A changelog entry costs 3 credits ($0.03). A task costs 2 credits ($0.02). A feedback item costs 1 credit ($0.01).
No per-seat charges. Teams pay $15/month or $25/month for the team features (shared projects, role-based access, configurable task workflows). Add as many team members as you want. The credit pool is shared across all projects and all members.
Why Reads Must Be Free
This is the most important pricing decision we made, and it's the one most AI memory tools get wrong.
An AI agent working on a project should query context constantly. At session start, it loads high-priority rules. Before working on CSS, it queries for CSS-tagged patterns. Before deploying, it checks for deployment warnings. Before building UI, it loads the design system. Before picking up a task, it reads the task details and notes.
If reads cost credits, the agent (or the developer configuring it) has an incentive to query less. Fewer queries means less context loaded. Less context means more mistakes. The pricing model would actively undermine the product's value.
Free reads mean the agent queries without hesitation. Bootstrap loads everything in one call. The agent re-queries after compaction. It checks the team feed at session start. It loads task notes before starting work. None of this costs anything. The agent uses the platform as aggressively as it needs to.
The same logic applies to status changes, notes on tasks, and updates to existing entries. These are the interactions that make the platform useful. Charging for them would discourage the back-and-forth between agents and humans that makes collaborative development work.
Why Context Is Free
Context is the entry point. A developer signs up, connects via MCP, and stores their first rules, decisions, and warnings. If this costs credits, the developer is spending before they've seen the value. That's friction at the worst possible moment.
Free context means the developer can populate their entire project knowledge base during the trial without thinking about cost. They can store 100 entries, 200 entries, 500 entries. They can experiment with types, tags, scopes, and priorities. They can frontload their entire project brief and see the difference at session start.
By the time the trial ends, the developer has seen the difference between a cold start session and a bootstrapped one. The decision to subscribe is based on experienced value, not a feature comparison table. $5/month for a tool you've already been using every day is straightforward.
What Our Own Usage Taught Us
We've been using Minolith on every project at Move Digital and Momentum Hosting since we built it. Real projects, real agents, daily usage. Here's what we learned about how developers actually consume the platform.
Storage: 0.5MB
After months of heavy daily use across multiple projects, our total storage is half a megabyte. That's $0.025/month in storage credits.
Context entries, tasks, changelog entries, feedback items, runbook definitions, agent definitions. These are all structured database records measured in bytes. A context entry with a title, body, type, tags, scope, and priority is roughly 500 bytes. A thousand of them is half a megabyte.
The only service that generates meaningful file storage is Styleguide assets (uploaded images like logos and icons). Even there, a typical project's brand assets total 10-20MB. At 5 credits per MB per month, that's 50-100 credits ($0.50-$1.00).
For structured text data, storage is a non-issue. The numbers speak for themselves.
Credit consumption
Even with heavy daily use across multiple projects, we found it difficult to reach the 500 credit limit included in the base plan. We were creating tasks, publishing changelog entries, collecting feedback, defining agents, and updating styleguide tokens regularly. Our usage was comfortably within the allowance every month.
It's possible to exceed 500 credits if you're running a very active project with frequent task creation and changelog updates. But the point is that normal, productive use doesn't create anxiety about going over. You're not watching a meter tick up wondering if your agent's next action will cost you. The allowance is designed to cover real work with room to spare.
What this means for pricing
The $5/month base plan covers realistic usage for solo developers. Credit consumption scales with project activity, not with team size or the number of sessions you run. The reads that make up most of your agent's interactions are free, and the writes that cost credits happen at a natural pace that fits within the allowance.
Why Not Per-Seat
Per-seat pricing would make Minolith more expensive for teams and wouldn't reflect how the platform is actually used.
Consider a development studio with 8 developers and 3 named agents. At $10/seat/month (a modest per-seat price), that's $80/month for the humans alone. The agents aren't even counted.
With Minolith's model, the same studio pays $15/month for the Teams plan with 1,500 credits. All 8 developers and all 3 agents share the credit pool. Everyone has access to every project they're assigned to. The cost is $15/month regardless of headcount.
Per-seat pricing also creates perverse incentives. Studios would limit who has access to keep costs down. Junior developers wouldn't get accounts. Freelancers brought in for a sprint would be excluded. The tool becomes a restricted resource instead of shared infrastructure.
The credit model means access is free. Usage costs credits. Add as many people as you need. The team that uses the platform most pays the most, which is fair because they're getting the most value.
Why Not Free Tier
We considered a free tier. Many SaaS products offer one. The logic is simple: free users become paid users over time.
The problem: a free tier for Minolith would mean hosting data indefinitely for accounts that never convert. Context entries, agent definitions, changelog pages, styleguide assets. All stored, all served, all costing us infrastructure even if the account never pays a cent.
For a bootstrapped product running on its own infrastructure, that's a risk we couldn't justify at launch. The 14-day trial with 500 credits serves the same purpose: developers try the platform with real usage, see the value, and decide whether $5/month is worth it. The trial is generous enough to frontload an entire project and run it for two weeks.
What We'd Do Differently
Honestly, not much. The credit model has held up well against real usage.
Credits might be too generous. At 500 credits included with the $5/month base, most solo developers will never hit overage. That's good for developers but it means the base plan covers a lot of ground. If we were starting over, we might include 300 credits instead of 500. But changing this now would feel like a bait-and-switch for existing users, so 500 stays.
The Philosophy
Developer tools should charge for value delivered, not for access granted. Reads are value received by the developer. Writes are value stored by the developer. Charging for writes and giving reads for free aligns the pricing with the value exchange.
A developer who stores 50 high-signal context entries and queries them hundreds of times per month is getting enormous value from the platform. They pay for the 50 writes and get unlimited reads. That's fair. A per-seat model would charge them the same whether they stored 5 entries or 500.
The credit model also respects how AI agents work. Agents query constantly. They check context before every task. They load the bootstrap response at every session start. They read task notes, feed entries, and styleguide tokens throughout the session. If any of these cost credits, the agent would need to be taught to conserve, which directly contradicts the purpose of having persistent context.
The best pricing model is the one where the customer never thinks about it. $5/month, 500 credits, reads are free, context is free. Use the platform. Build your project. The pricing takes care of itself.
Built by Minolith. Persistent project memory for AI coding agents. $5/month, unlimited projects, no per-seat charges.