How to quickly monetize through MuleRun: A real-world perspective on building a next-generation AI agent
In the past year, agent products have sprung up everywhere, and platforms have emerged one after another.
Coze, n8n, dify, relevance AI, Ant Toolbox, Baidu Qianfan, Alibaba Bailian, and so on—the list goes on and on.
But for ordinary users, how can they make money through AI Agents?
It’s as difficult as climbing to heaven.
I’ve been using the MuleRun platform for the past few months.
Develop agents on it.
The entire process, from setup and iteration to actual revenue generation, has been successfully completed.
During this process, I developed some new ideas about how to use agents.
In particular, MuleRun’s upcoming Builder tool.
It showed me a completely new way of building.
Today I’ll share three parts:
-
How I made money on MuleRun (Real Data)
-
Comparison of different agent construction methods
-
A more user-friendly build method: Why MuleRun’s Builder pattern may become mainstream
Let’s start by talking about what MuleRun is.
MuleRun is an AI Agent and AI app store:
-
Developers: You can publish your own AI agents and applications here. Set a price for each run. You can make money as long as someone uses them.
-
User: There are all kinds of AI products here. Image processing, video processing, job processing, finance, games—they’re all available. They can solve many real-world problems.
-
Platform: Provides the basic capabilities for building AI Agents/applications, including large models, MCP, Pages, and payment.
Let me start with my experience of making money on MuleRun.
Part 1: How to quickly monetize through MuleRun
Case Study
I’ve built several products on MuleRun, most of which are built using n8n.
Poster design, ID photo design, and YouTube thumbnail generators—these apps were created by simply making whatever came to mind.
After it was released, it was discovered that the only one actually used was the YouTube thumbnail generator.
At the time, MuleRun’s n8n mode only supported form interaction, resulting in a mediocre user experience.
So I redid it using iframes, which involved writing code to develop a webpage and embedding it on the Mulerun platform. The functionality was the same, but the user experience was better.
This product is very simple to use. Just enter a description of your YouTube video, choose a style, select how many images to generate, and it will appear.
Link: Youtube Awesome Thumnail
These two YouTube thumbnail products brought me about $1,200.
As you can see in this image, my earnings are divided into two parts: real money and points.
On MuleRun, users pay points using an agent. What can creators do with these points?
MuleRun provides basic services, such as large models and MCP capabilities.
Creators use these points to cover API costs.
When should I earn US dollars, and when should I earn points?
See how users pay:
-
When users purchase points and use your agent, you earn US dollars.
-
You earn points by using the points given to you by the platform.
But both points and US dollars are real rewards.
Why do I say that?
When I’m developing, I need to call the model API, which definitely costs money. MuleRun has its own API service, so I can directly use points to call the API, saving me some development costs.
This creates a cycle:
-
You use the points you earn to pay for development costs (adjusting the model, MCP, etc.).
-
Points/USD paid by users using your agent will be credited back to your account.
-
Because the price is higher than the cost, you won’t lose money as long as there are users.
In other words, when you become an agent on MuleRun, you don’t need to worry about your account balance or pay upfront.
Once the product is running smoothly, it becomes an automatic money-making machine, and that’s without me even promoting it myself.
To be honest, MuleRun will help you promote your products.
However, there are too many products on the platform, and relying solely on the platform to promote them will limit traffic. You have to find your own way, so I think that at this stage, I haven’t done any promotion.
If you develop and launch a product and leave it there, and it generates this much revenue, that’s already pretty good.
The two products didn’t take long to launch, only two months in total. I was only responsible for launching them, and then I just left them there most of the time.
The product itself is simple enough, without any complicated logic.
Here are the specific data for these two products:
n8n version of YouTube thumbnail generator:
-
Launch time: 3 months
-
Total number of runs: Approximately 440+
-
Pricing: 30 points per generation
-
Total earnings: Approximately $110 USD + points
An iframe version of the YouTube thumbnail generator:
-
Launch time: 2 months
-
Total number of runs: Approximately 2400+
-
Pricing: 30-330 points per generation
-
Total earnings: Approximately $1050 USD + Points
The development process from 0 to 1
The development process can be divided into two methods:
N8N method: simple and fast
The process has four steps:
-
Deploy and set up your n8n workflow locally
-
Test confirmed there are no problems.
-
Export the JSON configuration file and upload it to MuleRun.
-
Fill in the application information (description, cover image, etc.) and submit for review.
The whole process can take only a few hours, making it ideal for quickly validating ideas.
iframe method: flexible and controllable
This method requires three steps:
1. Develop your website
Write code to build a complete web application, calling the model APIs of MuleRun or other platforms; you can implement any functionality you want in this step.
2. Integrate with the MuleRun platform
This is the core issue; two things need to be addressed:
-
Authentication accessUser authentication adapted for MuleRun
-
Billing AccessIntegrate billing logic in appropriate locations.
For example, if you create a product that generates raw photos, you can charge users after they successfully generate the photos.
3. Deployment and Launch
Deploy your application to the cloud (such as Vercel) and obtain an accessible domain name.
Enter this domain name in the MuleRun creation form.
Just submit it for review and you’re done.
The core differences between the two methods
-
N8NLow-code, quick to learn, suitable for validation needs.
-
iframeRequires development skills, but functionality and user experience are fully controllable, suitable for long-term products.
Below, I will compare the actual differences between these two methods in detail, including development costs, maintenance difficulty, and user experience.
Uploading steps
-
First, apply to become a Creator on the MuleRun platform. A response will typically be received within 5 business days.
-
Create an Agent in the Creator backend and fill in the relevant information. Currently, you can choose between n8n or iframe methods. For n8n, you only need to upload the n8n JSON configuration. For iframe, you need to upload the website URL.
-
After submitting your application for review, wait for the platform to approve it. Once approved, you can officially launch and start earning money.
Methodology
1. Find requirements that have already been validated.
Method 1: Look for cross-platform opportunities
I like to find scenarios that have already been validated, scenarios that exist on other platforms but not on MuleRun.
We can do that, for example you can take a look:
-
What services sell well on Fiverr?
-
What are some of the most popular AI tools on Product Hunt lately?
-
What AI applications are people discussing on Twitter?
These places already have real users paying for services, proving that the demand exists.
You just need to move it to MuleRun and reimplement it using the Agent method.
Method 2: Use Reddit to uncover real needs
Another method I often use is to look for needs on Reddit.
Reddit has an AI Q&A and AI search feature that’s really useful.
For example:
Let’s say I want to create a resume optimization agent.
I would do it like this:
-
First, use AI search to conduct preliminary research.
-
Ask the AI on Reddit: Help me find out what problems people are currently encountering with resume optimization.
-
The AI will list a bunch of related discussion posts.
-
-
Enter the discussion to see details
-
Click into those posts to see users’ real complaints and needs.
-
Pay attention to the highly-rated replies; they often represent common pain points.
-
-
Delve deeper into vertical sectors
-
Find the dedicated sections for resumes or job postings (such as r/resumes, r/jobs).
-
Continue to observe these sectors:
-
What problems have you all encountered?
-
Does anyone already have a solution?
-
How did they do it?
-
Are users satisfied with the existing solution? Where can it be improved?
-
-
-
Organize and verify
-
Write down these problems and solutions.
-
Check if there are any recurring requirements.
-
Assess whether these needs are suitable for being addressed by an agent.
-
Why is this method effective?
Because what you find is not an imagined need, but the pain points that real users are experiencing.
The fact that these people are discussing this openly in the community indicates that:
-
The problem is widespread, not an isolated case.
-
The problem is serious enough that they are willing to spend time seeking help.
-
There may not be a good solution on the market yet.
We develop agents based on these real needs, aiming to improve success rates.
2. Your own SOP
There’s a classic concept in the international independent developer community called**“Scratching Your Own Itch”**(Scratching one’s own itch).
It means:Solve your own problem first.。
This isn’t some profound principle, but it’s a product development method with a high success rate.
Advantage 1: You have in-depth knowledge of the field.
You don’t need to spend time doing research or conducting interviews, because you are the user yourself.
You know where the pain points are, you know where existing solutions are ineffective, and you know what kind of solutions are truly effective.
Advantage Two: You have sustained motivation and enthusiasm.
What’s the worst thing about product development? Giving up halfway through.
But if you are solving your own problem, you will have the continuous motivation to improve it.
Because you use it every day, you can feel its value every day.
Advantage 3: You have a natural verification scenario
You don’t need to find test users; you yourself are the best test user.
Every time you use it, you can discover problems and think of ways to improve. This rapid feedback loop is something money can’t buy.
However, not all your problems are worth turning into a product.
You need to ask yourself three questions:
-
Is this problem painful enough?
- If you only encounter it occasionally, or if you can just ignore it, it might not be worth doing.
-
Do other people have this problem?
-
Search on Twitter, Reddit, and Xiaohongshu to see if anyone is complaining about similar issues.
-
If you’ve found it, congratulations, you’ve found a real market demand.
-
-
Are the existing solutions good enough?
-
If there are already good products on the market, you may need to reconsider.
-
But if existing solutions are ineffective, too expensive, or too complex, then that’s your opportunity.
-
Where to begin?
My suggestion is:Identify pain points in daily workflows。
-
What you do repeatedly at work
-
The tools or processes you frequently complain about
-
You always wish there was a tool that could…
These are all potential product opportunities.
Remember this:
The problem you’re facing is likely encountered by thousands of other people as well. The difference is that most people choose to endure it, while you choose to solve it and turn it into a product.
3. Publicly built
Let’s first talk about why “Build in Public” has become one of the most popular methods in the independent developer community.
What is traditional product development like?
They hide in a dark room, spending months or even a year secretly developing their ideas, fearing that their creativity will be copied, and only launch the product to the market when it is perfect.
And the result? Either they found that nobody wanted what they made, or they discovered that similar products already existed on the market.
Build in Public is the exact opposite.
From the very first day you generate an idea, share your development process, thoughts, progress, and even failures through public channels.
This may sound counterintuitive, but it is one of the most effective ways to promote a product.
Why is Build in Public so effective?
1. Building Trust: Transparency makes users feel involved in the product’s growth.
Users see your daily progress, how you solve problems, and how you make decisions.
They will feel a sense of participation, which will translate into recognition and support for the product.
When the product was officially launched, they were not only users, but also witnesses and even co-builders.
2. Obtain feedback: Early adopters will proactively provide suggestions.
You don’t need to spend money on user research or find test users.
Your followers will proactively tell you which feature is useful, which design is ugly, and which has a bug.
This feedback is invaluable, helping you optimize your product before it even goes live.
3. Build assets: Your shares will become searchable content, continuously attracting new users.
Every tweet and every share is a digital asset of yours; your content will be found when someone searches for related topics.
This content will continuously bring you new followers, creating a positive cycle.
Choose a suitable platform
You need to have your own social media accounts.
However, not every platform is suitable for everyone. The most important thing is to choose a platform that you feel comfortable with and can stick to.
What exactly will you share?
Share your development progress, data insights, thought process, and lessons learned. You don’t need to be overly detailed or professional—authenticity and consistency matter most.
Share what product you’re building, your progress, your thoughts on the product and AI. This naturally attracts people who resonate with your journey.
Key points to remember:
Consistency beats perfection. A simple “Fixed a bug today” is better than nothing. Share both successes and failures—stories like “Spent 6 hours debugging only to find a silly mistake” build trust and authenticity. Most importantly, provide value rather than constantly promoting. Share what you’ve learned and useful insights; product promotion happens naturally as a result, not as the goal.
4. Establish a cyclical mechanism
Establish a continuously operating closed loop:
Development → Launch → User Feedback → Data Analysis → Redevelopment
Even if you complete the entire closed loop, you still won’t make money.
The problem is often not in execution, but in direction. What you need to rethink is not how to optimize.
Rather: What is it that users are willing to pay for?
5. Follow the right platform
Most importantly, follow the platform’s direction.
The platform will provide them with directions that they believe need to focus on. These directions are ones that they have researched and believe have market potential, and following them will not cause any major problems.
On platforms like MuleRun,The cycle from idea to making money can be very short.。
You might have an idea today, implement it tomorrow, and have users paying for it the day after.
This rapid positive feedback will give you the motivation to keep going.
The second part follows.
I will share a comparison of different agent construction methods with you.
And why I believe the new build method will change the entire way agents are developed.
Part Two: Practical Comparison of Agent Construction Methods
Current Mulerun Agent construction method
1. n8n Workflow orchestration tool
The core of these tools is drag-and-drop visual arrangement.
You define the Agent’s execution flow by connecting various nodes (LLM calls, API calls, conditional judgments, etc.).
2. iframe embedding method
This was one of the ways MuleRun supported in its early days: you developed a complete web application locally or on another platform and then embedded it into the MuleRun platform via an iframe.
2.1 AI Applications
Enhance the functionality of your application by calling upon large AI models.
2.2 Agentic Applications
In web applications, integrate agent development frameworks, such as LangChain and ADK, which are open agent frameworks.
Multi-dimensional comparative analysis
I will compare these two approaches from several key dimensions:
1. Development threshold
n8n Workflow tool
It has a low barrier to entry; no coding is required, and a working agent can be created in a few hours, but understanding the concepts of nodes and processes is necessary.
iframe embedding method
-
AI Applications (2.1): Moderate entry barrier, requires some development skills
-
Agentic Applications (2.2): This has the highest barrier to entry, requiring full-stack development capabilities and a deep understanding of the Agent framework.
2. Ability Cap
n8n Workflow tool
The upper limit is low, and it is limited by the type of platform node, making it difficult to achieve truly intelligent decision-making.
iframe embedding method
-
AI Applications (2.1): Medium potential, capable of creating excellent functional tools.
-
Agentic Applications (2.2): Highest potential, enabling truly intelligent agents to handle complex reasoning and decision-making.
3. Maintenance costs
n8n Workflow tool
It has low maintenance costs and a visual interface that is easy to understand and modify, but complex processes are difficult to maintain.
iframe embedding method
The maintenance cost is high, requiring the maintenance of the entire application stack and operations, but it is completely controllable.
4. User Experience
n8n Workflow tool
User experience is tool-based, the interface is limited by platform templates, and the interaction process is rigid.
iframe embedding method
The user experience is completely controllable and can be made very sophisticated, but it requires a lot of development and design work.
Therefore, we can draw a conclusion from these two methods: those with low barriers to entry have low upper limits, and those with high upper limits have high barriers to entry.
Part 3: Mulerun Builder: The Next-Generation Agent Building Paradigm
A new consensus is forming.
Over the past six months, a new consensus has emerged in the AI community:
Agent = Base Agent with autonomous decision-making capabilities + Knowledge to guide tasks + Tools to complete tasks + Interfaces connecting various parts + Continuous performance optimization
In terms of a specific technology stack, it would be:
Claude Agent SDK + Skills + Tools + Programmatic Tool Calling
I’ll use a specific example to explain this paradigm.
Case Study: Building a Government Subsidy Application Agent
Let’s say I want to be an agent who helps small and medium-sized enterprises apply for government subsidies.
Under the new paradigm, I would do this:
Step 1: Select Base Agent
I would choose Claude Agent SDK as my base agent. Why?
Because it comes with the capabilities required by modern agents:
-
System 2 Thinking LoopAutomatic processing of application materials analysis, policy matching, and solution selection.
-
Context ManagementAutomatic management of application progress and company information
-
Error handling and retriesAutomatically handles missing materials and re-plans the application process.
-
Tool calling capabilityDiscovery, selection, and invocation of natively supported tools
Previously, I had to implement these capabilities myself using code, or by dragging and dropping many nodes into n8n.
Now, they are encapsulated in the Base Agent.
Step 2: Provide vertical domain knowledge
I need to write some specification files or Markdown documents describing the expertise required for subsidy applications:
-
Various subsidy policy provisions (technology innovation subsidies, employment stabilization subsidies, R&D expense subsidies, etc.)
-
Application qualifications and threshold requirements
-
Materials Preparation Checklist and Precautions
-
Common reasons for rejection and coping strategies
This knowledge is not present in the large models themselves, but for policy experts, it is their core competency.
This means that even if you can’t write code, as long as you are a domain expert, you can build valuable agents.
Step 3: Equip the necessary tools
In the form of Skills, I can provide the Agent with:
-
Intelligent form filling (automatically extracts company information and fills it into the application form)
-
Document compliance check (verification of business licenses, financial statements, and other documents)
-
Application progress inquiry
-
Document generation and export
Because it uses Skills encapsulation, the Base Agent has the ability to call these tools, and Claude Code’s progressive disclosure capability can save a lot of tokens during operation.
Completed: A working agent
At this point, I have completed version 1.0 of the government subsidy application agent.
It can:
-
Accepts multimodal input (text descriptions, photos of company licenses, financial statement documents).
-
Quickly match suitable subsidy programs based on policy database.
-
Intelligent assessment of application success rate
-
Automatically fills out the application form and generates a complete materials package.
-
Track application progress in real time and receive reminders for follow-up actions.
Throughout the entire development process, I didn’t write a single line of Agent framework code, nor did I interfere with any process nodes; I only provided knowledge and tools.
Why did this paradigm completely change the rules of the game?
1. Redefining the meaning of development
In the traditional paradigm, developing an agent means:
-
Write code to define the process
-
Drag nodes to orchestrate logic
-
Handling various technical details
In the new paradigm, developing an agent means:
-
Provide domain knowledge
-
Choose the appropriate tools
-
Describe the expected behavior
Agent development has shifted from a technical task to a knowledge integration process.
2. It completely changed the relationship between thresholds and ceilings.
Traditionally, low barriers to entry mean low ceilings, and high ceilings mean high barriers to entry, but the new paradigm breaks this rule:
-
Barrier to entry: Nearly no code required, anyone can get started.
-
Upper limit: Possesses complete reasoning, planning, and tool invocation capabilities, and can handle complex tasks.
This is the first time we’ve been able to build truly intelligent agents in a near-code-free manner.
3. The focus of agent development has been shifted to the right place.
In the traditional paradigm, developers spend 80% of their time on:
-
Debugging process
-
API processing
-
Management Status
-
Optimize performance
In this new paradigm, developers spend 80% of their time on:
-
Organize domain knowledge
-
Choose the appropriate tools
-
Optimize Agent Behavior
-
Testing and iteration
This is what agents should focus on.
MuleRun Builder: Making the New Paradigm Accessible to Everyone
Understanding the new paradigm is one thing, but actually using it is another. Although this paradigm is very powerful, it still has quite a few barriers for many people:
-
How to find the skill you need from 30,000+ skills?
-
How to properly configure MCP and tools?
-
How can knowledge be transformed into a form that an agent can understand?
This is why MuleRun needs to be a Builder.
**The core concept of Builder:**The user experience should be extremely simple, the product’s potential should be high enough, the operational burden should be close to zero, and the business loop should be seamlessly connected.
Mulerun aims to transform the process of building an agent into a process of conversing with AI:
-
**You don’t need to understand the technical details.**Simply describe what you want the agent to do.
-
You don’t need to filter SkillsMulerun will help you filter.
-
**You don’t need to write documentation.**Through dialogue, Builder will help you structure your knowledge.
-
**You don’t need to know deployment.**Everything is done in the cloud; once the test is passed, it can be launched with one click.
It’s like training a new employee. You don’t need to tell him how to use a computer or how to open a file. You just need to tell him what tasks he needs to complete and what he should pay attention to.
Builder’s three core capabilities
1. Natural Language-Driven Construction
The Builder itself is an Agent, which helps you build the Agent through multi-round, interview-style dialogues.
Through dialogue, the Builder will gradually build a complete Agent.
2. Fully cloud-based development experience
Experience building, testing, and iterating on a purely cloud-based agent.
3. Seamless integration into the commercialization system
This is the biggest difference between Builder and other tools: on MuleRun, the entire process from development to monetization is a closed loop.
-
One-click listingOnce the agent is built, it can be directly published to the MuleRun marketplace.
-
Automatic billingThe platform handles all payments and revenue sharing.
-
User ManagementNo need to build your own user system
-
Data AnalysisView usage and revenue in real time.
-
Iterative optimizationRapid iteration based on user feedback
This means you can verify the commercial value of your agent in the shortest possible time.
The Money-Making Advantages of a New Paradigm
Why is it said that the new paradigm is easier to make money? Because it solves several key problems:
1. Reduce iteration costs
-
In the traditional approach, feature iteration requires rewriting code or rearranging processes.
-
Under the new paradigm, iterative costs are extremely low, requiring only the addition of new knowledge or skills.
2. Accelerate the cycle from idea to revenue.
-
Traditional approach: Idea → Development (weeks) → Deployment → Promotion → Monetization
-
New Paradigm: Idea → Build (hours) → One-click Launch → Earn Money Instantly
This ability to iterate and validate rapidly is especially important in the AI era.
Case Study: The Actual Effect of Builder
The MuleRun team created an image generation agent using Builder.
The whole process only took 10 minutes:
-
Describe your needs through dialogue.
-
The Builder automatically selects the appropriate skills.
-
Configure image generation parameters
-
Test Results
-
One-click online
This agent has the following features:
-
Image generation in various styles
-
Intelligent parameter adjustment
-
Good user interaction
-
Complete error handling
Using the traditional method, this would take at least several days.
Demo link:https://youtu.be/rCk58_F0jag
Future Prospects of a New Paradigm
I believe that the new paradigm will become the mainstream way of building agents by 2026.
There are several reasons:
1. Continuous improvement in large-scale model capabilities
The reasoning and planning capabilities of Claude, GPT, and Gemini are rapidly improving, and the Base Agent will become increasingly powerful, which means that we will need to do less and less scaffolding work.
2. The thriving Skills ecosystem
As the Skills ecosystem develops, the available tools will become increasingly abundant, which will continuously expand the capabilities of Agents.
3. Commercialization maturity
Platforms like MuleRun are creating a seamless ecosystem from building to monetizing, making it easier to earn money and attracting more people to join the ecosystem.
4. Shift in industry perception
More and more people will realize that the core value of an agent lies not in its technical implementation, but in its domain knowledge and problem-solving capabilities. This will encourage more domain experts without technical backgrounds to participate in agent development.
Conclusion: Becoming a co-builder of the new paradigm
In today’s sharing, I want to convey a few core points:
1. The paradigm for agent construction is undergoing a fundamental change.
2. The new paradigm has found a new balance between the threshold and the upper limit.
3. MuleRun Builder is a productization practice of a new paradigm.
if you:
-
I have an idea for an agent, but I haven’t been able to find a suitable tool.
-
We are using an existing framework to build agents, but we are encountering difficulties in deployment and monetization.
-
He is an expert in a certain field who wants to transform knowledge into an agent.
Welcome to the beta testing of MuleRun Builder and become one of the first co-builders of this new paradigm.
Beta testing will begin on January 15, 2026.
