Skip to main content
Building reliable agentic applications is harder than deploying web applications. Agents can run for minutes to hours and need durable execution, sandboxed code execution, and access to files and data from APIs. Tensorlake’s Agentic Runtime provides serverless compute, durable execution, sandboxed code execution, and other foundational infrastructure to ship high-throughput data-centric agents.

​
Framework Agnostic

Tensorlake is framework agnostic, you can use any framework to build applications and workflows. You can use OpenAI Agents SDK, Claude Code SDK, Langchain or any other frameworks you already use with Tensorlake. 
from tensorlake.applications import application, function
from agents import Agent, Runner, WebSearchTool

@application()
@function()
def deep_research(prompt: str) -> str:
    agent = Agent(
        name="DeepResearchAgent",
        instructions="You are a deep research agent. Thoroughly investigate the topic using web search.",
        tools=[WebSearchTool()]
    )
    
    result = Runner.run_sync(agent, prompt)
    return result.final_output

​
HTTP Endpoints for Agents and AI Workflows

Tensorlake automatically creates an HTTP endpoint when you deploy your agents and workflows. This makes it easy to integrate them with applications and other systems. 
from tensorlake.applications import application, function
from agents import Agent, Runner, WebSearchTool

@application()
@function()
def deep_research(prompt: str) -> str:
    agent = Agent(
        name="ResearchAgent",
        instructions="You are a research assistant."
    )
    
    result = Runner.run_sync(agent, prompt)
    return result.final_output
This application is deployed as an HTTP endpoint at https://api.tensorlake.ai/applications/deep_research. Your code is going to start running whenever a new request is received on that endpoint.

​
Autoscaling for High Throughput Agents

Agents often run much longer than a typical web request. Tensorlake scales function containers based on concurrent requests, so you can run many agent sessions in parallel without operating queues or orchestrators.

​
Built-in Durable Execution for Recovering from Failures

A single agent request can incur many calls to tools and LLMs. Failures are common at scale. Durable execution means retries can resume from the point of failure instead of starting over, which reduces cost and time to complete the task.

​
Sandboxes for Running Untrusted Code

Code generation is often the most reliable way to get deterministic results from LLMs, like answering questions to mathematical problems, or when information is behind an HTTP API. Running untrusted code requires sandbox infrastructure to ensure the code is safe to run. Tensorlake functions run in sandboxes automatically, so you have sandbox infrastructure built into the platform. 
from typing import Any

@function()
def run_code(code: str) -> Any:
  # eval(code) 
  # Execute untrusted code in a sandboxed environment
  # Your implementation can restrict libraries, filesystem access, network, and runtime limits
  ...

​
Tracing and Observability

Understanding the path of a request through the agentic application is crucial for debugging and observability. Every function is automatically traced in your application. You can observe logs, exceptions, timing information, and cold starts by looking at the execution timeline.

​
Distributed Execution for Complex Applications

Applications can be composed of multiple functions with different compute requirements and dependencies. Tensorlake builds function images and runs functions in separate containers while serving requests transparently, without you wiring RPC calls or queues. Function-to-function calls are durable by default, so if a step fails, the request can resume from the last successful step. 
@function()
def call_weather_api(city: str) -> str:
    ...

@function()
def convert_celsius_to_fahrenheit(celsius: float) -> float:
    return (celsius * 9/5) + 32

@application()
@function()
def get_weather(city: str) -> str:
    weather = call_weather_api(city)
    fahrenheit = convert_celsius_to_fahrenheit(weather)
    return fahrenheit

​
Declarative Concurrency Control

Tensorlake functions processes one request at a time by default. But, in some cases you may want to process multiple requests concurrently in the same container. Use the max_concurrency setting to allow up to N concurrent requests per container. This is useful when your agent loop is I O bound and you want to reuse a warm container across multiple sessions. 
@function(max_concurrency=8)
def deep_research(req) -> str:
   ...

​
File Systems for Context Offloading

State-of-the-art agents use the filesystem to offload context and to download and inspect large files without loading them fully into memory. You can attach ephemeral disk to your functions by specifying the disk size. 
import asyncio
import shutil
from claude_agent_sdk import query, ClaudeAgentOptions

async def run_agent(prompt: str):
    options = ClaudeAgentOptions(
        system_prompt="You are an expert developer. Write code to solve the problem.",
        permission_mode='acceptEdits',
        cwd="/tmp/workspace"
    )
    
    async for message in query(prompt=prompt, options=options):
        print(message)

@application()
@function(ephemeral_disk=2)
def code_generator(prompt: str) -> bytes:
    asyncio.run(run_agent(prompt))
    
    # Zip the generated files and return
    shutil.make_archive("/tmp/output", "zip", "/tmp/workspace")
    
    return open("/tmp/output.zip", "rb").read()

​
Declarative Dependency Management

Tensorlake uses real containers to run your functions, so you can configure the base image and install any dependencies you need. 
from tensorlake.applications import Image, function

image = (Image(base_image="python:3.11-slim", name="my-custom-image")
            .run("pip install google-genai")
        )

@function(image=image)
def my_function(req) -> str:
   ...

​
Map-Reduce for On-demand Large-scale Data Processing

Use Map-Reduce for on-demand processing of large volumes of data. Fan out work across a list in parallel, then aggregate the results. 
from pydantic import BaseModel
from tensorlake.applications import application, function

class TotalSum(BaseModel):
    value: int = 0

@application()
@function()
def sum_squares(total_numbers: int) -> TotalSum:
    squares = square.map([i for i in range(total_numbers)])
    return sum_total.reduce(squares, TotalSum(value=0))

@function()
def square(number: int) -> int:
    return number ** 2

@function()
def sum_total(total: TotalSum, number: int) -> TotalSum:
    total.value += number
    return total
See Map-Reduce for blocking and non-blocking patterns.

Next Steps

Jump straight into building a serverless agentic code interpreter in under 5 minutes.