Introduction

What is Ziet?

Ziet is a serverless platform for building and deploying AI agents. Focus on writing Python code while Ziet handles all the infrastructure, scaling, and observability.

No Infrastructure

No servers, databases, or DevOps. Just write Python and deploy.

Auto-Scaling

Scale from zero to millions of requests automatically.

Built-in Integrations

Google, OpenAI, Stripe, Twilio, and more—out of the box.

Observable by Default

Track every action, memory operation, and agent decision.

How It Works

Ziet provides two powerful approaches: Agentic Approach: Build intelligent agents with Actions, Memory, and Strategies
Application Approach: Build serverless APIs with Endpoints and Database

Agentic
Application

from ziet import Action, Agent, PickActionsStrategy, HandOffStrategy

@Action(id="search_flights", name="Search Flights", description="Search for flights")
def search_flights(origin: str, dest: str) -> list:
    # Your code here
    return results

@PickActionsStrategy(picks=2, allow_repeats=False)
@HandOffStrategy(agents=["review_agent"])
@Agent(
    id="search_agent",
    name="FlightSearcher",
    description="Search and analyze flight options",
    instructions="""
    Search for flights using multiple sources, analyze options,
    and hand off to review agent for final recommendation.
    """,
    actions=["search_flights", "compare_prices", "check_availability"]
)
class FlightSearchAgent:
    pass  # Agent behavior is defined by instructions and strategies

Deploy and invoke:

ziet deploy

curl -X POST https://api.ziet.ai/agents/search_agent/run \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"origin": "SFO", "dest": "NYC"}'

from ziet import Endpoint, db

@Endpoint(
    id="get_flights",
    method="GET",
    path="/flights"
)
def get_flights(origin: str, dest: str) -> dict:
    """Fetch flights from database."""
    flights = db.query("flights") \
        .where("origin", origin) \
        .where("dest", dest) \
        .all()
    
    return {
        "status": 200,
        "body": {"flights": flights}
    }

@Endpoint(
    id="create_booking",
    method="POST",
    path="/bookings"
)
def create_booking(flight_id: str, user_id: str) -> dict:
    """Create booking in database."""
    booking_id = db.insert("bookings", {
        "flight_id": flight_id,
        "user_id": user_id,
        "status": "confirmed"
    })
    
    return {
        "status": 201,
        "body": {"booking_id": booking_id}
    }

Deploy and invoke:

ziet deploy

curl https://api.ziet.ai/flights?origin=SFO&dest=NYC

curl -X POST https://api.ziet.ai/bookings \
  -d '{"flight_id": "f123", "user_id": "u456"}'

Why Ziet?

Traditional Approach

Set up servers (EC2, ECS, Kubernetes)
Configure databases (Postgres, Redis, Vector DB)
Implement auth, rate limiting, monitoring
Write boilerplate for retries, timeouts, queues
Manage deployments, scaling, and infrastructure

Result: Weeks of work before writing agent logic.

With Ziet

Write Python functions with @Action decorator
Define agents with @Agent decorator
Run ziet deploy

Result: Production-ready agents in minutes.

Get Started

Install Ziet

pip install ziet

Write Your First Agent

Follow our quickstart guide to build a complete agent in 5 minutes.

Deploy

ziet deploy

Key Features

Actions

Serverless functions with built-in retries, timeouts, and error handling.

@Action(timeout=30, retries=3)
def process_data(data: dict) -> dict:
    return transformed_data

Learn more about Actions →

Agents

Autonomous agents that orchestrate multiple actions to complete complex tasks.

@PickActionsStrategy(picks=3, allow_repeats=False)
@HandOffStrategy(agents=["summarizer_agent"])
@Agent(
    id="researcher_agent",
    name="ResearchAgent",
    description="Research topics and gather information",
    instructions="""
    Research the given topic by searching multiple sources,
    picking the best 3 search actions, and gathering comprehensive data.
    Hand off to summarizer agent when complete.
    """,
    actions=["search_google", "scrape_websites", "search_news"],
    model="gpt-4o"
)
class ResearchAgent:
    pass  # Agent behavior is defined by instructions and strategies

Learn more about Agents →

Memory

Built-in key-value and semantic search for agent state.

from ziet import memory

memory.add(key="best_option", value={"price": 350})
best = memory.get("best_option")
results = memory.search("cheapest flights")

Learn more about Memory →

Endpoints

Serverless API endpoints—like AWS Lambda, but simpler.

@Endpoint(method="GET", path="/users/{user_id}")
def get_user(user_id: str) -> dict:
    user = db.query("users").where("id", user_id).first()
    return {"status": 200, "body": user}

Learn more about Endpoints →

Database

Persistent storage across all runs, agents, and endpoints.

from ziet import db

# Store data permanently
user_id = db.insert("users", {"email": "alice@example.com"})

# Query anywhere
user = db.query("users").where("id", user_id).first()

Learn more about Database →

Integrations

Pre-built integrations with popular services.

from ziet.integrations import google, openai, stripe

results = google.search("best restaurants SF")
response = openai.chat([{"role": "user", "content": "Summarize"}])
payment = stripe.create_payment_intent(amount=5000)

View all integrations →

Next Steps

Actions

Serverless actions

Agents

Intelligent agents

Memory

Temporary storage

Strategies

Agent orchestration

Endpoints

REST API endpoints

Database

Persistent storage

Integrations

Built-in integrations

API Reference

API documentation

​What is Ziet?

No Infrastructure

Auto-Scaling

Built-in Integrations

Observable by Default

​How It Works

​Why Ziet?

​Get Started

​Key Features

​Actions

​Agents

​Memory

​Endpoints

​Database

​Integrations

​Next Steps

Actions

Agents

Memory

Strategies

Endpoints

Database

Integrations

API Reference

What is Ziet?

How It Works

Why Ziet?

Get Started

Key Features

Actions

Agents

Memory

Endpoints

Database

Integrations

Next Steps