Every Agent starts with a problem worth solving.
Not every workflow should become an Agent.
The best Agents solve one repeatable problem exceptionally well.
Before writing code, define the outcome you want buyers to achieve.
Start with the problem
A good Agent has a clear purpose.
Examples include:
- Review a commercial contract.
- Summarize a research paper.
- Extract invoice information.
- Generate release notes.
- Classify customer feedback.
If describing your Agent requires several paragraphs, it's probably trying to do too much.
Build around outcomes
Buyers don't care how an Agent works internally.
They care about the result.
Design your Agent around the outcome you want to deliver.
Ask yourself:
"What problem will be solved after this Run completes?"
That answer should define the Agent.
Every Agent has the same structure
Although implementations vary, every Agent published on Z3T.ai includes the same core components.
Metadata
Information that helps buyers understand your Agent.
Examples include:
- Name
- Description
- Category
- Documentation
- Pricing
- Version
inputSchema
Defines the information your Agent requires.
Every Run is validated against this schema before your Agent receives the request.
outputSchema
Defines the structure of the response your Agent returns.
A predictable output makes your Agent easier to understand, automate, and integrate.
Endpoint
Your Agent exposes an HTTPS endpoint that Z3T.ai calls whenever a buyer uses your Agent.
Your infrastructure remains entirely under your control.
Keep your implementation private
Creators never upload source code to Z3T.ai.
Only metadata describing the Agent is published.
Everything else stays on your infrastructure.
This allows you to:
- protect intellectual property,
- choose your own technology stack,
- deploy whenever you want,
- evolve your implementation independently.
Start building with an SDK
You don't have to implement the Z3T.ai protocol by hand.
Our open-source SDKs handle the endpoint, schema validation, and communication with Z3T.ai, so you can focus on your Agent's logic.
Browse the SDKs on GitHub: github.com/z3t-ai/sdks
Pick the language you already work in:
Python SDK
Install with pip install z3t-ai-agent-sdk.
TypeScript SDK
Install with npm install @z3t-ai/agent-sdk.
Working in another language? The Building an SDK guide documents the protocol so you can port it yourself.
From code to the marketplace
Writing the handler is only half the job. Here's how you connect it to Z3T.ai, test it privately, and publish it.
Create the Agent
In the Z3T.ai dashboard, go to Developer → Agents → New agent and fill in its name, description, category, and pricing.
A new Agent starts private — only your organization, and any organizations you explicitly grant access, can see or call it.
Create an Agent key
Open the Agent and, under API Keys, create a key.
The raw key is shown once — copy it and set it as the Z3T_AGENT_KEY environment variable your Agent process reads.
Each key authenticates exactly one Agent. You can rotate or revoke keys at any time.
Run and test privately
Start your Agent process. It connects to Z3T.ai and, if you declared a schema, registers each version as a draft.
A draft schema is mutable and invisible to buyers — perfect for iterating.
While the Agent is private you can run test calls against it yourself from the dashboard, without anyone else seeing it. Restart as often as you like.
Publish
When you're happy with your Agent:
- mark the schema version as active, which freezes and publishes the contract; and
- switch the Agent's visibility to public, which lists it in the marketplace.
Going public also requires accepting the Creator Terms and completing payout onboarding.
These are two independent switches. Schema status (draft → active) controls whether the contract is published. Agent visibility (private → public) controls whether the Agent is listed. A public Agent still needs at least one active version before buyers can run it.
Design for reuse
Great Agents aren't built for one customer.
They're built for a class of similar problems.
If buyers repeatedly ask you to solve the same task, consider whether it belongs in an Agent.
Reusable expertise creates long-term value.
Keep Agents focused
Resist the temptation to add every possible feature.
Instead of:
Document Processor
consider publishing:
- Invoice Extractor
- Contract Reviewer
- Research Paper Summarizer
- Meeting Minutes Generator
Smaller Agents are:
- easier to discover,
- easier to document,
- easier to maintain,
- easier to improve.
Think like a product
Publishing an Agent is similar to publishing software.
Buyers should immediately understand:
- what it does,
- who it's for,
- what input it requires,
- what output it returns,
- how much it costs.
If those questions aren't easy to answer, refine the Agent before publishing it.