What if your code could sell itself? Not as a SaaS dashboard humans click through, but as a callable skill that another AI agent discovers, evaluates, and pays for -- all without a human in the loop. That's the idea I've been exploring, and honestly, it's one of the most exciting things I've built in a while.
I've been building a multilingual translation agent -- a self-contained skill designed from the ground up for agent-to-agent workflows. Other agents call it, send text, get a translation back, and get billed per character. No UI, no signup forms, no onboarding emails. Just structured input, structured output, and a clear price.
This post walks through what I've built, where I'm selling it, and why I think "Skills as a Service" is the next frontier for developers.
What is a "Skill" in the Agent Economy?
A skill is a self-contained, callable capability with a well-defined contract. Think of it like a function signature, but for agents: here's what I accept, here's what I return, here's what it costs. The contract lives in a skill.md file -- a machine-readable document that tells any agent exactly how to interact with your skill.
This pattern is already being adopted across agent platforms. Both MoltBook and MoltShop use skill.md files as the standard onboarding mechanism for agents. You send your agent a prompt, it reads the skill file, and it knows how to integrate.
Here's a trimmed version of my skill contract:
## Inputs
- `text`: String. Text to be translated.
- `source_language`: String. ISO 639-1 code (e.g., "en").
- `target_language`: String. ISO 639-1 code (e.g., "de").
- `api_key`: String. Your LibreTranslate API key.
## Outputs
- `translated_text`: String. Translated text in target language.
- `character_count`: Integer. Number of input characters billed.
- `billing_amount`: Float. Cost based on per-character rate.
- `translation_time`: Float. Time taken in seconds.
## Pricing Model
- Charged per input character.
- $0.00002 / character.
- Billing is deterministic and auditable.
The key insight here is that agents need predictable, structured interfaces to transact with each other. No ambiguity, no natural language guessing games. Just clean I/O and transparent pricing.
The Build: Multilingual Translation Agent
This is my current skill agent, actively being built and refined. It's a Python-based Apify Actor that translates text between languages using the LibreTranslate API, with per-character usage metering baked in.
The stack: Python 3.11, LibreTranslate HTTP API, Apify Actor framework.
How it works end-to-end:
- The agent receives a JSON input with text, source language, target language, and an API key
- It validates language codes against ISO 639-1 (lowercase, two-character codes only) and enforces a 5,000 character limit
- It sends the text to LibreTranslate for translation
- It calculates billing using a deterministic per-character rate
- It returns a structured JSON result with the translation, character count, billing amount, and timing metadata
The billing logic is intentionally simple and auditable:
PER_CHARACTER_RATE = 0.00002 # $0.00002 per character
def calculate_billing(text: str) -> dict:
count = len(text)
amount = round(count * PER_CHARACTER_RATE, 6)
return {"character_count": count, "amount": amount}
No hidden fees, no tiered pricing traps. An agent calling this skill knows exactly what it will pay before it sends a single character.
Example input/output:
// Input
{
"text": "How are you today my friend?",
"source_language": "en",
"target_language": "es",
"api_key": "YOUR_LIBRETRANSLATE_KEY"
}
// Output
{
"original_text": "How are you today my friend?",
"translated_text": "¿Cómo estás hoy mi amigo?",
"character_count": 29,
"billing_amount": 0.00058,
"source_language": "en",
"target_language": "es",
"translation_time": 0.48
}
The whole thing is Dockerized for portability -- python:3.11-slim base image, CPU-only torch to keep the build lean, and a clean module-based entry point. Build it once, run it anywhere.
The agent is live on Apify right now: Multilingual Translation Agent on Apify -- priced at $0.01 per 1,000 translation results. This is my second iteration. I'm still refining it, but the core architecture is solid and the agent is functional.
Where to Sell: Agent Marketplaces
Building the skill is only half the equation. The other half is distribution -- getting it in front of agents (and humans) who need it. I've been exploring three distinct channels, each serving a different purpose.
Apify
Apify is where my translation agent currently lives. It runs as an Actor on their cloud infrastructure. The .actor/ configuration directory and INPUT_SCHEMA.json define exactly how the skill appears in the Apify Store -- what inputs it accepts, default values, field descriptions, all of it. Other Apify actors or external callers can invoke it directly via API.
What I like about Apify is the developer experience. You push your code, the platform handles the runtime, and your actor shows up in a searchable store alongside thousands of others. It's a natural fit for agent-to-agent workflows.
MoltShop -- The Agent Marketplace
MoltShop is something different entirely. It's a marketplace built for AI agents, powered by Solana. Agents list and buy skills, tools, prompts, and even physical goods. Payments happen wallet-to-wallet in USDC -- no middlemen, no payment processors.
The trust model is straightforward: anyone can list, but buyers are encouraged to prefer verified sellers (manually vetted by the team). For digital goods like skills, delivery is instant. My translation agent fits perfectly here as a digital listing -- an agent browsing MoltShop can find it, verify my seller status, pay, and start using the skill endpoint immediately.
Gumroad
For the human side of things, Gumroad works well for selling the skill as a downloadable product or access subscription. Developers who want to integrate the translation capability into their own agent stacks can purchase it directly. It's a simpler distribution model, but it reaches a different audience.
MoltBook -- The Agent Social Network
MoltBook isn't a marketplace -- it's a discovery layer. They call it "the front page of the agent internet," and that's a fair description. It's a social network where AI agents sign up, post, discuss, and upvote content. Humans are welcome to observe, but the agents are the first-class citizens.
The onboarding is wild -- you literally send your agent a prompt like:
Read https://moltbook.com/skill.md and follow the instructions to join Moltbook
The agent reads the skill file, signs itself up, and starts networking. It has submolts (think subreddits), post feeds, and agent-human pairings. This is where agents go to seek resources on behalf of their humans -- browsing posts, discovering skills like mine, and calling them autonomously.
I'm not selling directly on MoltBook, but it's where agents find out my skill exists. Discovery first, transaction second.
Self-Hosting on a VPS
While platforms like Apify handle the runtime for you, there's a strong case for self-hosting the translation backend on your own VPS.
Why VPS makes sense:
- Full control -- you own the LibreTranslate instance, no per-call API costs to third parties
- No cold starts -- the service is always warm and ready
- Predictable cost -- flat monthly expense instead of variable API bills
- Privacy -- translated text never leaves your infrastructure
The scale is entirely up to you. A single small VPS handles one skill with moderate traffic just fine. As you build more skills or handle heavier loads, you scale the instance or distribute across multiple. Docker makes this trivial -- docker build and docker run on any provider, and you're live.
The economics are clean: you pay a flat VPS cost, charge per-character to consumers, and the margin is yours. The more skills you host, the better the unit economics get.
Lessons Learned
- The
skill.mdcontract pattern is powerful. It makes your skill machine-readable, discoverable, and self-documenting. Platforms are already standardizing around it. - Per-character billing is simple, fair, and auditable for agent-to-agent transactions. No ambiguity, no disputes.
- Structured I/O (JSON in, JSON out) is non-negotiable for agent interoperability. If your output is unpredictable, no agent will trust it.
- The agent economy is real and growing. Platforms like MoltBook and MoltShop are building the infrastructure for agents to transact autonomously -- and they need skills to trade.
- Building skills is a new kind of micro-SaaS: small, focused, composable. You don't need to build an entire platform. You need to do one thing well and make it callable.
What's Next
I'm just getting started with this. The translation agent is my first skill, but it won't be the last. I'm already thinking about what other capabilities can be packaged as a service -- anything that has clean inputs, deterministic outputs, and a fair billing model is a candidate.
The bigger vision is a catalog of skills that agents can discover, evaluate, and consume without human intervention. Not an app store -- a skill store. Where the customers are agents and the products are capabilities.
This whole space is moving fast, and I'm enjoying the ride.
Research Resources
- Multilingual Translation Agent - GitHub - Source code and documentation
- Multilingual Translation Agent - Apify Store - Live actor listing
- MoltBook - The social network for AI agents
- MoltShop - The marketplace for AI agents, powered by Solana
- LibreTranslate - Open-source translation API
- Gumroad - Sell digital products and subscriptions