Inside Wabi and the rise of no-code agent mini-app stores

Breaking: a new path for distributing AI

On October 9, 2025, Replika founder Eugenia Kuyda announced Wabi, a no code platform for creating, remixing, and sharing agent mini apps. In a private beta with a small team, Wabi is positioning itself not as another all purpose chatbot but as a canvas for lightweight, task specific agents that anyone can assemble. The goal is to make building an agent feel like dragging blocks, then packaging and sharing it like a playlist. Kuyda framed Wabi as a personal software platform and confirmed she is shifting focus from Replika while staying on as a creative advisor there. That framing matters because it reimagines how AI reaches users. Instead of one giant interface that tries to do everything, distribution shifts to a feed of tiny, purpose built flows that snap together. Early details are in a Business Insider interview with Kuyda.

If Wabi sticks, it could mark the start of an agent app store era. Not a store for mobile apps, but for small agents that perform one job well. Imagine a shelf of mini apps that file routine travel refunds, triage your inbox, analyze sales calls, or draft a supplier dispute. Each is tuned to a narrow outcome and easily remixed for a new context.

From monolithic chatbots to composable workflows

The first generation of generative AI arrived as megasuites. A single app bundled chat, search, file tools, and sometimes voice. Users loved the breadth, then hit the ceiling when the interface could not mirror their workflow. Companies learned a similar lesson. One size fits all prompts fracture under messy edge cases. Every new user need demanded another brittle heuristic.

Agent mini apps flip the model and emphasize three ideas:

Narrow jobs and explicit handoffs. An agent that only handles airline receipts can be measured, tuned, and trusted more than a general travel bot.
Remixability. Users can fork a mini app, swap the data source, and share a version that matches their workplace. Think of it as GitHub for workflows.
Composability. Instead of building one giant assistant, teams chain mini apps into a runbook. Each step can be audited and improved without breaking the whole.

Concrete example: a Lunch in 10 mini app plans a weekday meal, checks your fridge inventory notes, generates a shopping list, and fires an order to the local grocer. Another mini app turns the same plan into a calendar block with a friendly summary and a nutrition note for your fitness log. You can swap the grocer step for Instacart or a local market. You can remove the nutrition note if you do not track macros. Small pieces, tightly scoped, endlessly recombined.

We have seen this shift coming in other corners of the agent world. The move from coding aide to fully agentic software is already visible in the shift from coding assist to software, and the browser itself is becoming a reliable execution surface as the browser becomes your agent. Wabi speaks to the same current, but reorients it around creation, remix, and share.

What Wabi is, and what it is not

Wabi is not a vertical agent for a single domain, and it is not a traditional no code website builder. The emphasis is on discover, remix, and share. That suggests a creator first network rather than a toolchain for internal teams only. The private beta and small team size imply a launch with a handful of high utility templates and a lean runtime where user trust is won by speed, transparency, and stability. If you have used Canva templates or browsed community pages in Notion, imagine that energy applied to agents that take real actions, not just draft content.

The strategic bet is clear. New distribution beats bigger models. If users can find, try, and trust a mini app in under a minute, creators will flood the shelf with variations. The best variations will win by measured outcomes, not by hype. That dynamic could reshape the generative AI market faster than another model upgrade.

The emerging agent stack, in plain language

To make an agent app store work at consumer scale, a new stack is taking shape. Here is the outline that is becoming visible.

1) Standards and interop: agents need a common plug

What the plug is. Developers need a simple way to connect agents to tools and data, no matter which model or vendor they use. The Model Context Protocol is emerging as that plug, a bit like a universal charging port for agents. It standardizes how tools and context are exposed to models, so a calendar connector or a file reader can be reused across many mini apps without bespoke code. For a security focused angle on this ecosystem, see how an MCP security platform frames trust and enforcement.
Why it matters. Without a common plug, every mini app is a snowflake. With it, creators can ship faster, and marketplaces can apply consistent safety checks. If Wabi supports such standards, remixing moves from hacky to first class.
Commerce layer. Open primitives for transactions let agents buy and sell on behalf of users while keeping control with merchants. OpenAI’s recent emphasis on agent commerce and built in tools illustrates the direction, with new primitives that no code platforms can wrap. You can see the approach in OpenAI’s new tools for building agents.

2) Memory and vector stores: what an agent should remember

Short term memory. Agents need scratchpads for the current task. This is often structured state plus transcripts of tool calls.
Long term memory. For personalization, agents should remember stable facts like preferences, saved entities, and outcomes. Vector stores such as Pinecone, Weaviate, and open source choices like pgvector or Chroma handle semantic recall. The winning pattern is to keep long term memory minimal and explicit. Store a few clean facts, not a mountain of chat logs.
Organizational memory. In business settings, agents read knowledge bases, ticket histories, product catalogs, and policy docs. The best practice is controlled ingestion. Index only what improves task success, tag it for provenance, and automate reindexing on change. Treat memory like a library with a front desk, not a warehouse where everything gets dumped.

3) Action and security: how agents touch the real world

Computer use and browsers. Many tasks require web navigation or desktop actions. A safe agent platform includes a headless browser sandbox, a permission ring to gate sensitive actions, and clear logs for every click and keystroke. Make clicks replayable and traceable.
Tool execution and quotas. Even simple mini apps call tools that can spend money or send messages. Use capability tokens with scopes and expiry, rate limits by tool, and a human in the loop checkpoint for new or risky actions.
Policy engines and guardrails. Policy should be code, not vibes. Teams use rule sets that declare what the agent can do, when, and with what input. This keeps security auditable and speeds compliance reviews. The best no code platforms will expose these guardrails with presets that ordinary creators can understand, and advanced teams can extend.
Observability and rollback. Every agent run emits a trace. Store traces with request IDs, tool results, and model snapshots. Let creators revert template versions and compare performance across variants.

Monetization and discovery: how creators get paid, and how users find quality

Marketplaces die without two things: an incentive for makers and a way for buyers to trust what they install. Agent mini app stores will be no different.

Monetization models to expect:
- Usage credits. Users buy a small pool of credits and spend them in mini apps, with revenue shared to creators.
- Feature unlocks. The base mini app is free. Premium unlocks one click actions, better connectors, or audit trails.
- Bundles. Teams buy a bundle of related mini apps for a department, like support or finance, at a flat seat price.
- Marketplace revenue share. The platform takes a small cut of paid runs or premium unlocks. Creators earn as their mini apps execute.
Discovery patterns that work:
- Task first search. People search outcomes, not model names. The query is get refund from airline for delay, not best travel agent.
- Trust signals. Badges for security review, verified connectors, and reproducible benchmarks. Reliability scores should factor into ranking.
- Remix lineage. Show parent and child templates, plus what changed. This makes reputation portable and promotes learning.
- Social proof that is hard to game. Aggregate completion rates and success metrics rather than star ratings alone.

Creators win when they can fork, improve, and be paid the moment their improvement ships. That is the loop Wabi and similar platforms want to unlock.

Why this speeds the iterate to ship loop for startups

Shipping reliable agents is hard because the surface area is large. Models, tools, data quality, and user intent all vary. A mini app approach narrows scope, which lets teams:

Set clear success metrics per job. A refund mini app either got money back or not. A sales call triage mini app either extracted fields and filed them or not.
Run controlled experiments. Variants can test different tool orders, prompts, or UI. The platform can roll forward the winner based on success rate and time to completion.
Reuse battle tested steps. If a calendar connector is reliable, everyone should use it. Do not rebuild basic steps every time.
Shorten review cycles. Security reviews are faster when each mini app has a small permission set and transparent traces.

The result is the rhythm every startup wants: narrow scope, fast experiments, automatic rollout, measured wins, repeat.

What to build now: concrete bets for the next six months

If you are racing to productize agent ecosystems, here are pragmatic build bets. Each has a buyer, a path to revenue, and a clear contribution to safety or speed.

MCP server kits for common tools
Ship ready to deploy connectors for calendars, email, spreadsheets, and help desks. Include tests, example traces, and a permission catalog. Sell enterprise support bundles.
Guardrail presets for risky actions
Provide policy packs for finance, healthcare intake, or customer communications. Each pack includes rules, redaction filters, and example audits. Offer a visual rule builder that non technical users can understand.
A runbook composer that chains mini apps
Let teams drag steps into a multi agent flow. Add versioning, traffic splitting for experiments, and per step metrics. Expose a safe mode that runs without actions for training.
Observability and rollback that anyone can read
Build a traces viewer with human readable steps, tool results, and decisions. Add a one click rollback when a new template underperforms. Integrate with incident channels.
A test harness for agents
Provide fixtures that simulate tool responses, rate limits, and error codes. Let creators run a battery of tests before publishing. Report a quality score tied to discoverability.
Identity, billing, and capability tokens
Offer a turnkey identity layer for agents, with scoped tokens and user consent flows. Meter usage per tool and per creator. Expose clean webhooks for finance teams.
Memory wrappers with explicit data edges
Ship utilities that mark what is stored, for how long, and why. Support field level encryption and subject access export by default. Make privacy a visible feature.
A policy driven storefront review
Publish review criteria, run static checks on templates, and require a minimum test score. Give creators clear feedback and time estimates for approval.

Twelve month forecast: what likely happens next

A default interop layer consolidates. One or two protocols will become the USB C of agents. Connectors turn into reusable assets across platforms. Remix becomes mainstream rather than a developer trick.
Built in action primitives spread. Computer use, web search, and file tools become standard capabilities of major model platforms. That reduces custom glue code and raises the bar for no code platforms to focus on experience, not plumbing.
Consumer agents focus on micro tasks with measurable outcomes. Refunds, returns, support escalations, billing disputes, schedule hygiene, and receipt categorization emerge as popular shelves in the store.
Security incidents drive visible policy. A few public mistakes force agent platforms to show permission scopes, action previews, and audit logs by default. This is healthy. It builds trust and standardizes guardrails.
Enterprise adoption favors hybrid. Teams mix private connectors and public templates. Winning platforms let companies curate an internal store that borrows from a public one, with central control over tools and data.
Creator economies form around templates. Top creators specialize by domain, not by model. They sell proven flows that work in finance, sales operations, or customer care, and they publish updates tied to measured outcomes.

How Wabi could change the map

If Wabi launches with clean primitives for remix, permissioning, and discovery, it can become a mass market venue for agent mini apps. A well known founder buys attention, but the flywheel requires three things that only great product design can deliver:

Creation that feels like play. If drafting a mini app feels like arranging magnets on a fridge, the store will fill with experiments. The platform can then surface the ones that work.
Trust signals that are readable by everyone. People need to see permissions, costs, and outcomes before they run anything. Good defaults here turn dabblers into repeat users.
A path from niche to staple. The platform should let a clever one off become a dependable staple with versioning, tests, and reviews. That is how a store stays fresh without becoming chaotic.

Practical touchpoints with today’s agent ecosystem

Two currents around Wabi’s thesis are worth watching closely. First is the continued hardening of browser based action, which turns the web into an execution substrate rather than a content destination. That arc is captured in the growing sense that the browser becomes your agent. Second is the steady normalization of agent to tool contracts through MCP and similar constructs. The security posture and governance models around those bridges are evolving quickly, as highlighted by an MCP security platform view from the field.

A founder’s playbook for the agent app store age

Start with a job that ends in a receipt. Pick tasks with clear outcomes and easy verification. Shipping value that can be checked builds both trust and metrics.
Work where users already are. Integrate with calendars, inboxes, spreadsheets, and browsers before inventing new canvases. Meet the user inside their real work.
Instrument everything. Emit traces, success flags, time to complete, and failure reasons. Use them to rank templates, allocate traffic, and pay creators.
Make remix safe. Let forkers change prompts and connectors, but inherit guardrails and tests. Keep permission scopes visible and tight.
Price simple. Charge for completed outcomes or small credit packs. Avoid per token confusion. Reward reliability with better placement and higher revenue share.

For the broader context on how agents are evolving from helpers to full software, it is worth seeing how the shift from coding assist to software reframes what product teams ship and measure.

The moment to build

Agent mini apps are not a footnote to larger models. They are the route by which models become useful to everyone. Wabi’s debut is a signal that distribution is moving from pages of chat to shelves of workflows, shaped by creators and standardized by shared plugs. The next year will belong to the teams that make these workflows easy to build, safe to run, and rewarding to share. That is the difference between a demo and a platform, between another chatbot and a store that millions might visit every day.

The agents are ready. The shelves are empty. Time to stock them.