Itura: Making it easy to deploy agentic applications

The world of agentic AI applications is rapidly moving from experimentation to production. That's why we're excited to announce that Itura, a cloud platform purpose-built for deploying Python-based agentic applications, is now available in open beta! If you're building AI agents using Python and want a streamlined way to get them into production without managing servers, Itura is designed for you.

What is Itura?

Itura is a serverless platform that lets you deploy your agentic applications to a secure, scalable cloud endpoint. Build your agents using your preferred Python frameworks, libraries, and LLMs, and let Itura handle the underlying infrastructure, deployment pipeline, scaling, and monitoring.

How Itura Works

Deploying your agent with Itura involves three easy steps:

1. Prepare Your Agent Code: Structure your agent logic so it can accept HTTP POST requests. Add a simple Flask /run endpoint to your Python script. This endpoint will receive invocation requests and trigger your agent. Also, define your dependencies in a requirements.txt file.

   # Example app.py
   from flask import Flask, request, jsonify
   import os
   
   app = Flask(__name__)
   
   @app.route("/run", methods=["POST"])
   def run_agent_endpoint():
       data = request.get_json()  # Pass parameters to the agent
       env_vars = os.environ  # Access environment variables
       agent_output = my_agent_logic(data, env_vars)
       return jsonify(agent_output)
   
   def my_agent_logic(params, env_vars):
       # Print statements are automatically capture by Itura
       print(f"{len(params)} parameters and {len(env_vars)} env variables received")
       # TODO: Implement your agent logic here using your favorite stack
       return {"message": "Agent executed successfully!", "output": "Agent output"}
   
   # Optional: for local testing
   # if __name__ == '__main__':
   #    app.run(debug=True, port=5001)

   
   

   Generate a requirements.txt file listing all necessary Python dependencies.

   # Example requirements.txt
   flask
   # Add other dependencies your agent needs
   # requests
   # openai
   # langchain

   
   

2. Connect to GitHub: Push your code (including app.py and requirements.txt) to a GitHub repository. Connect this repository to your Itura account via the Itura UI.

3. Add Environment Variables: Securely add any necessary environment variables (like API keys or configuration settings) through the Itura UI. These variables will be injected into your agent's runtime environment.

Once configured, Itura packages your code into a container, deploys it, and provides a unique endpoint URL (e.g., https://your-agent-name.agent.itura.ai) and a secret API key. Pushing new commits to your connected GitHub repository automatically triggers a new deployment.

Invoking Your Deployed Agent

Interact with your deployed agent via an HTTP POST request to the /run endpoint of its unique URL. Include your API key in the Authorization: Bearer header.

curl -X POST https://your-agent-name.agent.itura.ai/run \
     -H "Authorization: Bearer <your_api_key>" \
     -H "Content-Type: application/json" \
     -d '{"input": "Data for your agent"}'

Itura handles invocations asynchronously. A successful POST request returns a 202 Accepted response with a run_id.

{
  "run_id": "some-unique-run-identifier",
  "message": "Run request accepted and queued for execution",
  "status": "PENDING"
}

You can monitor the run's status (e.g., PENDING, RUNNING, COMPLETED, FAILED) via the Itura UI or by polling the /status/<run_id> endpoint. Logs are available in the UI upon completion.

Why we built Itura

While building agentic applications is becoming easier with frameworks like Langchain, CrewAI, and Autogen, deploying, managing, and scaling these applications reliably remains a significant challenge. Developers often get bogged down with infrastructure tasks (server provisioning, containerization, CI/CD pipelines, scaling policies, monitoring) instead of focusing on refining the agent's capabilities.

We built Itura to abstract away this operational complexity. Our goal is to provide a simple, robust platform where developers can deploy their Python agents quickly, iterate rapidly with GitHub integration, and scale effortlessly, all without becoming infrastructure experts. We want you to focus on building powerful agents, not managing servers.

Key Features

The key features of Itura are:

• Framework Agnostic: Use any Python agentic framework, LLM, or library. Trigger your logic from the Flask /run endpoint.
• Serverless & Scalable: Built on a serverless architecture, Itura automatically scales based on demand. You don't manage servers.
• CI/CD via GitHub: Integrates directly with your GitHub workflow for automatic deployments.
• Secure Execution: Agents run in isolated container environments. Environment variables provide a secure way to manage secrets.
• Logging & Monitoring: Standard output and error streams are captured and available in the Itura UI, along with execution history and status.

Technical Details

Itura is a serverless platform that uses Docker containers to run your agentic application. Itura is built on top of AWS and Google Cloud Platform. The following specifications apply:

• Runtimes: Python 3.9 - 3.13 supported.
• Resources (Per Invocation): 1GB RAM, 10 GB temporary storage.
• Execution Time: Up to 10 minutes per invocation.

Get Started with the Open Beta

We invite you to try Itura during our open beta. Focus on building your agents, and let Itura handle the deployment complexities. A generous free tier is available to help you get started. We're eager to hear your feedback.

Get Started!