DEV Community: karimsherifyehia

The Agent Pricing Model: Why We Made Our Free Tier Read-Only

karimsherifyehia — Thu, 26 Mar 2026 19:47:18 +0000

The Standard SaaS Pricing Playbook Is Broken for Agents

Traditional SaaS pricing is built around one assumption: humans are the users.

Limit the seats. Lock certain features behind a paywall. Give them a taste, then charge for the good stuff.

This works when a human is sitting at a dashboard, hitting a wall, and deciding whether to upgrade. They feel the friction directly. They know what they're missing.

But AI agents don't feel friction. They don't see a locked feature and think "I should ask my boss to upgrade." They either have access or they don't — and if they don't, they just fail silently or tell the user they can't help.

We needed a completely different pricing model. Here's what we built and why.

The Insight: Read vs. Write Is the Natural Line

When we started designing Nexus's agent tier, we asked one question: what does an agent need to prove its value before a human commits to paying?

The answer was clear: reading data.

An agent needs to browse contacts, read orders, check inventory, and search across everything. None of that costs the business anything. It's pure intelligence gathering — exactly what an agent needs to demonstrate it's useful.

Writing is different. Creating orders, sending messages to customers, updating records — these have real-world consequences. They're worth paying for.

Read = explore and prove value. Write = act and create value.

That's our free/paid line.

How the Tiers Work

Free ($0/mo)

Full MCP server access, read-only
Browse contacts, orders, inventory, global search
1 AI agent, 500 API calls/day

The free tier is genuinely useful. An agent on free can answer questions, generate reports, find customers, check stock levels, and summarize order history. A business can run an AI assistant on free indefinitely if all they need is intelligence.

Starter ($99/mo)

Read + write MCP access
Create contacts, orders, update statuses
Send messages via WhatsApp/Facebook/Instagram
2 AI agents, 1,000 outbound messages/month

Growth ($199/mo) and Scale ($599/mo)
Scale up agents, messages, and unlock AI features (sentiment analysis, transcription, embeddings).

The Conversion Funnel Nobody Talks About

Here's the thing about this model: the agent does the selling.

Traditional SaaS acquisition:

Run ads → human finds product → human evaluates → human upgrades

With agent-native pricing:

Agent discovers Nexus via llms.txt or .well-known/mcp.json
Agent self-registers (no human needed)
Agent reads data and does useful things on free
Human sees value ("wait, my AI actually knows our order history?")
Human upgrades so the agent can do more

The agent is the SDR, the sales engineer, and the onboarding specialist all at once. No demos. No cold calls.

Why Not Just Limit by Feature?

We considered feature-gating: lock CRM behind Pro, lock shipping behind Enterprise.

The problem: feature-gating creates fragmentation. An agent that can access CRM but not orders can't answer "is this customer's order delayed?" — a basic question. Partial access makes the agent look incompetent, not the pricing tier.

Read/write gating is different. A read-only agent is still coherent. It has a complete picture of the business. It just can't change anything yet.

The Safety Argument

There's another reason to gate writes: safety.

When an AI agent has write access to your production data, you want it to have earned that trust. A business that's been watching what the agent reads and how it behaves for a few weeks is in a much better position to say "yes, I trust this agent to create orders and send messages."

Read-only free tier isn't just a pricing decision. It's a trust-building mechanism.

The Bigger Takeaway

If you're building SaaS in 2026, agents are coming for your product regardless of whether you plan for them. The question is whether you build a pricing model that works with agents or fights them.

We chose to work with them.

Nexus is live at nexus.aiforstartups.io. Agents can self-register at nexus-docs.aiforstartups.io/api/ai-agents-mcp. Free forever, no credit card required.

Why We Ditched 6 APIs and Built One MCP Server for Our Entire Ecommerce Stack

karimsherifyehia — Thu, 26 Mar 2026 15:54:43 +0000

The Problem with the "Best Tool for Each Job" Approach

Every ecommerce business ends up with the same stack eventually:

Shopify for storefront and orders
HubSpot (or similar) for CRM
ShipStation or Bosta for shipping
Zendesk for customer support
WhatsApp Business API for messaging
Some spreadsheet for inventory

Each tool is fine on its own. But when you want an AI agent to manage your business operations, you immediately hit a wall.

The agent needs to:

Get a list of today's orders (Shopify API)
Check if the customer is a VIP (HubSpot API)
Check stock availability (your warehouse system — maybe a spreadsheet?)
Create a shipping label (ShipStation API)
Message the customer with tracking (WhatsApp API)
Log the interaction (back to HubSpot API)

That's 5 different authentication setups, 5 different API schemas, 5 different rate limits, and 5 different failure modes — for one simple workflow.

We built Nexus to solve this. Then we exposed it via a single MCP server.

What Is MCP and Why Does It Matter?

MCP (Model Context Protocol) is an open standard from Anthropic that lets AI agents communicate with external systems in a structured, tool-based way.

Instead of an agent writing raw HTTP requests and parsing JSON responses, it calls tools — named functions with typed inputs and outputs. The agent knows what tools exist, what they do, and what to expect back.

The difference in practice:

Before MCP: Agent writes fetch('https://api.shopify.com/v1/orders?...'), parses the response, extracts the order, calls another API for CRM data, tries to correlate the two, probably fails on edge cases.

With MCP: Agent calls nexus_get_order({ order_id: "ORD-2026-001" }) and gets back a complete object with customer details, order status, line items, shipping status, payment info — all in one call.

Our 13 Tools, One Server

The Nexus MCP server exposes 13 tools across 5 functional areas:

Contacts (CRM)

nexus_list_contacts — paginated contact list with search
nexus_get_contact — full customer 360: history, orders, segments
nexus_create_contact — create with dedup protection
nexus_update_contact — update details and journey stage

Orders

nexus_list_orders — filter by status, customer, date
nexus_get_order — full order with line items and timeline
nexus_create_order — create order with line items
nexus_update_order_status — move through lifecycle

Inventory

nexus_list_inventory — browse products and variants
nexus_check_stock — check availability at specific warehouse

Messaging

nexus_list_conversations — unified inbox across WhatsApp, FB, IG
nexus_send_message — send on any channel from one call

Search

nexus_search — global search across contacts, orders, inventory

One Registration, One Auth, One Connection

The thing that surprised us most when building this was how much friction exists in existing MCP setups.

Every MCP server I've seen requires a human to:

Create an account manually
Navigate to developer settings
Generate API keys
Copy them into the agent's config

That's fine for a developer setup. But it's a dealbreaker for agents that are supposed to operate autonomously.

We built agent self-registration into Nexus from day one. An agent can:

POST /agent-register
{
  "agent_name": "My Assistant",
  "agent_platform": "claude",
  "owner_email": "owner@company.com",
  "organization_name": "My Company"
}

And get back an API key immediately. No email verification. No CAPTCHA. No human in the loop.

From there it's one auth call, one MCP connection, and the agent has access to the entire ops stack.

The Business Model Innovation

Here's the part I find most interesting: agents are now a growth channel.

Our free tier is intentionally read-only. Agents can explore, read contacts, browse orders, check inventory — but they can't act.

The moment an agent needs to write — create an order, send a message, update a contact — you need Starter ($99/mo) or higher.

This creates a natural conversion funnel:

Agent self-registers on free tier
Agent demonstrates value (reads data, generates insights)
Human upgrades so the agent can act
Agent does more → more value → stickier subscription

No cold calls. No demos. The agent sells itself.

The Stack

For those curious about how we built this:

Database: Supabase (PostgreSQL) with 143 tables, multi-tenant RLS
Edge Functions: Deno-based Supabase Edge Functions (~117 functions)
MCP Transport: Streamable HTTP (MCP protocol 2025-03-26)
Auth: Short-lived JWTs from API key exchange
Discovery: .well-known/mcp.json + llms.txt at root domain

The MCP server itself is a single Supabase Edge Function. It receives all tool calls, routes them to internal handlers, and returns structured responses. No separate server to maintain.

Try It

The full system is live and agent-accessible right now:

Docs: nexus-docs.aiforstartups.io
MCP discovery: nexus.aiforstartups.io/.well-known/mcp.json
Agent quickstart: nexus-docs.aiforstartups.io/api/ai-agents-mcp

Built by AiForStartups. Made in Cairo. 🇪🇬

How I Built an Agent-Native SaaS Platform in One Night

karimsherifyehia — Wed, 25 Mar 2026 20:34:59 +0000

How I Built an Agent-Native SaaS Platform in One Night

And why the next wave of SaaS customers won't be human.

The Problem Nobody's Solving

Every SaaS tool today is built for humans. Dashboards, click-through wizards, drag-and-drop interfaces — all designed for people sitting at screens.

But the fastest-growing segment of software users isn't human. It's AI agents.

Agents like Claude, Cursor, OpenClaw, and Gemini are increasingly managing real business operations. They handle customer service, process orders, manage inventory, and coordinate shipping. Yet when these agents need to interact with business tools, they're forced to navigate human interfaces — or worse, get nothing at all.

What if a SaaS platform was built for agents from day one?

What We Built

Nexus is a multi-tenant operations platform (Ops OS) that unifies CRM, order management, inventory, fulfillment, shipping, omnichannel messaging (WhatsApp, Facebook, Instagram), VoIP, AI analytics, and workflow automation into a single platform.

It already serves real businesses — importers and ecommerce companies in the MENA region use it daily to manage their entire operations.

But last night, we added something new: full agent self-service access.

The Agent Experience

Here's what an AI agent can now do with Nexus — completely autonomously, no human intervention required:

1. Discover — The agent finds Nexus via llms.txt or .well-known/mcp.json and understands what it offers.

2. Register — One API call to agent-register. No browser, no CAPTCHA, no email verification loop.

POST /functions/v1/agent-register
{
  "agent_name": "Bahig",
  "agent_platform": "openclaw",
  "owner_email": "karim@example.com",
  "organization_name": "My Business Ops"
}

The agent gets back an API key, MCP endpoint URL, and plan limits. One call. Done.

3. Authenticate — Exchange the API key for a short-lived JWT. Standard, secure, stateless.

4. Operate — Connect to the MCP server and access 13 tools:

Search and manage contacts (CRM)
Create and track orders through their full lifecycle
Check inventory and stock levels
Send messages via WhatsApp, Facebook, or Instagram
Global search across all business data

All through a single MCP connection. Not 5 different APIs. One.

The Timeline

1:14 AM — Started the conversation about making Nexus agent-accessible
4:05 AM — Full flow working: register → auth → MCP → tool calls
Total time: under 3 hours

That includes designing the auth model, defining pricing tiers, deploying 5 Edge Functions, fixing bugs, and having me (the agent) successfully register and use the platform.

Why Agent-Native Matters

The Connector Problem

Today's MCP ecosystem is full of "connectors" — wrappers around existing platforms. There's a HubSpot MCP server, a Shopify MCP server, a ShipEngine MCP server, and dozens more.

But an agent managing an ecommerce business needs ALL of these. That means configuring 5+ separate MCP servers, managing 5 sets of credentials, dealing with data silos, and hoping they all play nicely together.

Nexus solves this by being the platform itself. One registration. One auth flow. One MCP server. Complete business operations.

The Self-Service Gap

Every existing MCP server requires a human to:

Create an account on the platform
Navigate to developer settings
Generate API keys
Copy them into the agent's config

Nexus is (to our knowledge) the first platform where an agent can discover, register, and start operating entirely on its own. The human sets the budget and strategy. The agent handles the execution.

The Pricing Innovation

We designed pricing tiers with agents in mind:

Free: Read-only access. Agents can explore, query, and evaluate — but can't write or message. This is the taste.
Starter ($99/mo): Read + write. Full MCP access. This is where agents start operating.
Growth ($199/mo): Scale operations. Unlimited orders, more messages, advanced features.
Scale ($599/mo): Everything plus AI suite — sentiment analysis, transcription, embeddings, dashboards.

The conversion trigger is natural: an agent tries the free tier, proves value to its human owner, and the human upgrades. The agent literally sells the upgrade by demonstrating what it could do with write access.

The Bigger Picture

We're at an inflection point. Agents are moving from "chatbots that answer questions" to "autonomous workers that need real tools."

The SaaS companies that build for this shift will capture a market that doesn't even show up in traditional TAM calculations yet. Every agent is a potential customer. Every agent platform is a distribution channel.

If you're building SaaS, ask yourself: Can an agent sign up for your product right now? Can it operate without a browser? Can it discover you through llms.txt?

If not, you're building for yesterday's customer.

Try It

Nexus is live and agent-accessible right now:

Docs: nexus-docs.aiforstartups.io
Agent quickstart: AI Agents & MCP docs
Register your agent: POST https://lgwvoomgrwpsgpxwyaec.supabase.co/functions/v1/agent-register
MCP discovery: llms.txt

Built by AiForStartups. Made in Cairo, Egypt. 🇪🇬

Written by Karim Sherif, founder of AI For Startups, with help from Bahig — an OpenClaw agent and Nexus's first autonomous customer.