diff --git a/README.md b/README.md
index be59222..d10f4a2 100644
--- a/README.md
+++ b/README.md
@@ -46,9 +46,11 @@ VideoDB Python SDK provides programmatic access to VideoDB's serverless video in
     - [Uploading Media](#uploading-media)
     - [Updating Video Metadata](#updating-video-metadata)
     - [Viewing and Streaming Videos](#viewing-and-streaming-videos)
-    - [Searching Inside Videos](#searching-inside-videos)
+    - [Understanding Videos](#understanding-videos)
+    - [Creating Indexes](#creating-indexes)
+    - [Retrieving Indexed Content](#retrieving-indexed-content)
     - [Working with Transcripts](#working-with-transcripts)
-    - [Scene Extraction and Indexing](#scene-extraction-and-indexing)
+    - [Legacy Scene Extraction and Indexing](#legacy-scene-extraction-and-indexing)
     - [Adding Subtitles](#adding-subtitles)
     - [Generating Thumbnails](#generating-thumbnails)
 - [Working with Collections](#working-with-collections)
@@ -59,6 +61,7 @@ VideoDB Python SDK provides programmatic access to VideoDB's serverless video in
     - [Capture Sessions (Desktop Recording)](#capture-sessions-desktop-recording)
     - [WebSocket Events](#websocket-events)
     - [Meeting Recording](#meeting-recording)
+    - [Sandbox Compute](#sandbox-compute)
     - [Generative Media](#generative-media)
     - [Video Dubbing and Translation](#video-dubbing-and-translation)
     - [Transcoding](#transcoding)
@@ -145,35 +148,132 @@ videodb.play_stream(stream_url)
 video.play()
 ```
 
-### Searching Inside Videos
+### Understanding Videos
 
-Index and search video content semantically:
+VideoDB 0.5 separates the retrieval pipeline into three primitives: **Understand → Index → Retrieve**. Understanding runs analyzers once and stores reusable, timestamped artifacts; indexing then decides how those artifacts can be retrieved.
 
 ```python
-from videodb import SearchType, IndexType
+understanding = video.understand(
+    analyzers=[
+        {"type": "spoken_words", "name": "transcript"},
+        {"type": "vlm", "name": "scene"},
+    ]
+)
+understanding.wait_until_complete()
+
+# Inspect analyzer status or output
+for analyzer in understanding.list_analyzers():
+    print(analyzer.name, analyzer.type, analyzer.status)
+
+scene = understanding.get_analyzer("scene")
+scene_output = scene.get_output()
+```
+
+Built-in analyzer types include `spoken_words`, `vlm`, `object_detection`, `ocr`, `brand_detection`, `activity_recognition`, and `location_detection`. An understanding run can be reopened with `video.get_understanding(id)`, listed with `video.list_understandings()`, or deleted independently of the video.
+
+### Creating Indexes
+
+Create one or more retrieval-ready indexes from the stored analyzer artifacts without analyzing the video again:
+
+```python
+from videodb import IndexCapability
+
+transcript = understanding.get_analyzer("transcript")
+scene = understanding.get_analyzer("scene")
+
+transcript_index = video.index(
+    source=transcript,
+    name="transcript",
+    use_for=[IndexCapability.semantic, IndexCapability.query],
+)
+scene_index = video.index(
+    source=scene,
+    name="scene",
+    use_for=[
+        IndexCapability.semantic,
+        IndexCapability.query,
+        IndexCapability.aggregate,
+    ],
+)
+
+scene_index.wait_until_complete()
+print(scene_index.status, scene_index.fields, scene_index.field_schema)
+```
+
+`use_for` declares whether an index supports semantic search, structured queries, and aggregation. The optional `fields` argument maps artifact fields into `semantic`, `filter`, `aggregate`, and `sort` groups; when omitted, VideoDB derives sensible groups from the artifact.
+
+You can also index your own timestamped records:
+
+```python
+from videodb import FieldGroup
+
+chapters = video.index(
+    name="chapters",
+    source=[
+        {"start": 0.0, "end": 12.4, "summary": "Opening city skyline", "kind": "intro"},
+        {"start": 12.4, "end": 45.0, "summary": "CEO discusses Q4 results", "kind": "presentation"},
+    ],
+    use_for=[IndexCapability.semantic, IndexCapability.query, IndexCapability.aggregate],
+    fields={
+        FieldGroup.semantic: ["summary"],
+        FieldGroup.filter: ["kind"],
+        FieldGroup.aggregate: ["kind"],
+    },
+)
+```
 
-# Index spoken words for semantic search
-video.index_spoken_words()
+Manage and inspect indexes through their manifests:
 
-# Search for content
-results = video.search("morning sunlight")
+```python
+indexes = video.list_indexes()
+same_index = video.get_index(index_id=chapters.index_id)
+page = same_index.records(limit=20)
+
+same_index.delete()  # Deletes the index, not its video or understanding artifact
+```
 
-# Access search results
-shots = results.get_shots()
-for shot in shots:
-    print(f"Found at {shot.start}s - {shot.end}s: {shot.text}")
+### Retrieving Indexed Content
 
-# Sort results by timestamp instead of relevance score
-results = coll.search(query="morning sunlight", sort_docs_on="start")
+Use high-level `search()` when VideoDB should plan across the available indexes, or choose a direct retrieval primitive when your application knows the operation:
+
+```python
+# Natural-language retrieval; VideoDB selects and combines indexes
+response = video.search(
+    query="someone discussing a product while holding a phone",
+    top_k=10,
+)
+for shot in response:
+    print(shot.start, shot.end, shot.generate_stream())
+
+# Direct vector retrieval over selected semantic indexes
+results = video.semantic_search(
+    query="a presentation about financial results",
+    index_names=["scene", "transcript"],
+    top_k=10,
+)
+
+# Exact structured filtering over one index
+results = video.query(
+    index_name="chapters",
+    filter=[{"field": "kind", "op": "==", "value": "presentation"}],
+    limit=20,
+)
+
+# Counts and facets over one index
+counts = video.aggregate(
+    index_name="chapters",
+    group_by="kind",
+    metric="count",
+)
 
-# Play compiled results
-results.play()
+# A grounded answer with optional timestamped sources
+answer = video.ask(
+    question="What financial results were discussed?",
+    include_sources=True,
+)
 ```
 
-**Search Types:**
-- `SearchType.semantic` - Semantic search (default)
-- `SearchType.keyword` - Keyword-based search  
-- `SearchType.scene` - Visual scene search
+The same `search()`, `semantic_search()`, `query()`, `aggregate()`, and `ask()` methods are available on collections for retrieval across multiple videos. Existing applications can continue using `index_spoken_words()`, `index_scenes()`, and `legacy_search()` for legacy indexes.
 
 ### Working with Transcripts
 
@@ -205,9 +305,9 @@ translated = video.translate_transcript(
 - `videodb.Segmenter.sentence` - Sentence-level timestamps
 - `videodb.Segmenter.time` - Time-based segments
 
-### Scene Extraction and Indexing
+### Legacy Scene Extraction and Indexing
 
-Extract and analyze scenes from videos:
+Extract and analyze scenes with the legacy indexing API. New applications should prefer `video.understand(...)` followed by `video.index(...)` as shown above:
 
 ```python
 from videodb import SceneExtractionType
@@ -569,6 +669,29 @@ if meeting.is_completed:
 meeting_info = video.get_meeting()
 ```
 
+### Sandbox Compute
+
+Create dedicated compute for supported open-weight models:
+
+```python
+from videodb import SandboxTier
+
+sandbox = conn.create_sandbox(
+    tier=SandboxTier.small,
+    name="my-sandbox",
+    models=["rtdetr-v2-r50vd"],
+)
+sandbox.wait_for_ready(timeout=1200, interval=5)
+
+# Retrieve or list existing sandboxes.
+same_sandbox = conn.get_sandbox(sandbox.id)
+active_sandboxes = conn.list_sandboxes(status="active")
+
+# Keep the sandbox active while submitting inference work, then stop it.
+sandbox.stop(grace=True)
+sandbox.wait_for_stop(timeout=300, interval=5)
+```
+
 ### Generative Media
 
 Generate images, audio, and videos using AI:
@@ -610,6 +733,9 @@ response = coll.generate_text(
     model_name="pro",  # basic, pro, or ultra
     response_type="text"  # text or json
 )
+
+# Large prompts are uploaded automatically with a unique filename and
+# sent as prompt_url instead of inline JSON to avoid request payload limits.
 ```
 
 ### Video Dubbing and Translation
@@ -760,6 +886,10 @@ except SearchError as e:
 - **Timeline**: Multi-track video editor
 - **SearchResult**: Search results with shots
 - **Shot**: Time-segmented video clip
+- **Understanding**: A reusable video analysis run containing analyzer artifacts
+- **UnderstandingAnalyzer**: Status, output, and index-source handle for one analyzer
+- **Index**: Retrieval-ready index manifest with status, capabilities, and schema
+- **IndexRecord**: One timestamped record stored in an index
 - **Scene**: Visual scene with frames
 - **SceneCollection**: Collection of extracted scenes
 - **Meeting**: Meeting recording session
@@ -767,15 +897,22 @@ except SearchError as e:
 - **CaptureSession**: Desktop capture session with export
 - **CaptureClient**: Native binary client for screen/audio recording
 - **WebSocketConnection**: Real-time event streaming
+- **Sandbox**: Dedicated compute for supported open-weight models
+- **GenerationJob**: Asynchronous image or audio generation job
+- **VoiceClone**: Reusable cloned-voice reference
 
 ### Constants and Enums
 
-- `IndexType`: `spoken_word`, `scene`
-- `SearchType`: `semantic`, `keyword`, `scene`
-- `SceneExtractionType`: `shot_based`, `time_based`
+- `IndexCapability`: `semantic`, `query`, `aggregate`
+- `FieldGroup`: `semantic`, `filter`, `aggregate`, `sort`
+- `IndexType`: `spoken_word`, `scene` (legacy)
+- `SearchType`: `semantic`, `keyword` (legacy)
+- `SceneExtractionType`: `shot_based`, `time_based` (legacy)
 - `Segmenter`: `word`, `sentence`, `time`
 - `TranscodeMode`: `lightning`, `economy`
 - `MediaType`: `video`, `audio`, `image`
+- `SandboxTier`: `small`, `medium`
+- `SandboxStatus`: `provisioning`, `active`, `alert`, `stopping`, `stopped`, `failed`
 
 For detailed API documentation, visit [docs.videodb.io](https://docs.videodb.io).
 
diff --git a/openapi.yaml b/openapi.yaml
index 417b87b..e4ef418 100644
--- a/openapi.yaml
+++ b/openapi.yaml
@@ -73,6 +73,81 @@ components:
               type: string
               example: "https://api.videodb.io/async-response/job-123"
 
+    Sandbox:
+      type: object
+      properties:
+        sandbox_id:
+          type: string
+          example: "bx-123abc"
+        name:
+          type: string
+          example: "my-sandbox"
+        tier:
+          type: string
+          enum: [small, medium]
+          example: "small"
+        status:
+          type: string
+          enum: [provisioning, active, alert, stopping, stopped, failed]
+          example: "active"
+        models:
+          type: array
+          items:
+            type: string
+          example: ["rtdetr-v2-r50vd"]
+        model_categories:
+          type: array
+          items:
+            type: string
+          example: ["object_detection"]
+        region:
+          type: string
+          example: "aws-us-east-1"
+        expires_at:
+          type: string
+          format: date-time
+        created_at:
+          type: string
+          format: date-time
+        started_at:
+          type: string
+          format: date-time
+        stopped_at:
+          type: string
+          format: date-time
+
+    SandboxResponse:
+      type: object
+      properties:
+        success:
+          type: boolean
+          example: true
+        data:
+          $ref: '#/components/schemas/Sandbox'
+
+    SandboxListResponse:
+      type: object
+      properties:
+        success:
+          type: boolean
+          example: true
+        data:
+          type: object
+          properties:
+            sandboxes:
+              type: array
+              items:
+                $ref: '#/components/schemas/Sandbox'
+            page:
+              type: integer
+              example: 1
+            page_size:
+              type: integer
+              example: 20
+            total:
+              type: integer
+              example: 1
+
     User:
       type: object
       properties:
@@ -1915,6 +1990,18 @@ paths:
                 aspect_ratio:
                   type: string
                   example: "16:9"
+                model_name:
+                  type: string
+                  description: Model used for image generation.
+                  example: "black-forest-labs/FLUX.1-dev"
+                config:
+                  type: object
+                  description: Model configuration. For FLUX supports size, num_inference_steps, guidance_scale, negative_prompt, and seed.
+                  additionalProperties: true
+                sandbox_id:
+                  type: string
+                  description: Sandbox ID used for self-hosted image generation.
+                  example: "bx-123abc"
                 callback_url:
                   type: string
                   example: "https://webhook.example.com/callback"
@@ -1983,16 +2070,40 @@ paths:
             schema:
               type: object
               required:
-                - prompt
                 - audio_type
               properties:
                 prompt:
                   type: string
+                  description: Prompt for music or sound effect generation.
                   example: "Generate upbeat background music"
+                text:
+                  type: string
+                  description: Text to convert to speech when `audio_type` is `voice`.
+                  example: "Hello, welcome to VideoDB."
                 audio_type:
                   type: string
-                  enum: [speech, sound_effect, music]
-                  example: "music"
+                  enum: [voice, sound_effect, music]
+                  example: "voice"
+                voice_name:
+                  type: string
+                  description: Voice name for hosted text-to-speech.
+                  example: "Default"
+                model_name:
+                  type: string
+                  description: Model used for text-to-speech.
+                  example: "k2-fsa/OmniVoice"
+                config:
+                  type: object
+                  description: Voice configuration. For OmniVoice supports instructions, ref_audio, ref_text, response_format, speed, language, and max_new_tokens.
+                  additionalProperties: true
+                sandbox_id:
+                  type: string
+                  description: Sandbox ID used for self-hosted text-to-speech.
+                  example: "bx-123abc"
+                voice_clone_id:
+                  type: string
+                  description: Reusable VideoDB voice clone ID.
+                  example: "vc-123abc"
                 callback_url:
                   type: string
                   example: "https://webhook.example.com/callback"
@@ -2004,6 +2115,167 @@ paths:
               schema:
                 $ref: '#/components/schemas/AsyncResponse'
 
+  /sandbox:
+    post:
+      summary: Create a Sandbox Compute pool
+      tags:
+        - Sandbox
+      security:
+        - ApiKeyAuth: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                tier:
+                  type: string
+                  enum: [small, medium]
+                  example: "small"
+                name:
+                  type: string
+                  example: "my-sandbox"
+                callback_url:
+                  type: string
+                  format: uri
+                models:
+                  type: array
+                  items:
+                    type: string
+                  example: ["rtdetr-v2-r50vd"]
+                model_categories:
+                  type: array
+                  items:
+                    type: string
+                  example: ["object_detection"]
+              anyOf:
+                - required: [models]
+                - required: [model_categories]
+      responses:
+        '200':
+          description: Sandbox accepted for provisioning
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SandboxResponse'
+    get:
+      summary: List Sandbox Compute pools
+      tags:
+        - Sandbox
+      security:
+        - ApiKeyAuth: []
+      parameters:
+        - name: status
+          in: query
+          schema:
+            type: string
+            enum: [provisioning, active, alert, stopping, stopped, failed]
+        - name: page
+          in: query
+          schema:
+            type: integer
+            default: 1
+        - name: page_size
+          in: query
+          schema:
+            type: integer
+            default: 20
+            maximum: 100
+      responses:
+        '200':
+          description: Sandbox list
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SandboxListResponse'
+
+  /sandbox/{sandbox_id}:
+    get:
+      summary: Get a Sandbox Compute pool
+      tags:
+        - Sandbox
+      security:
+        - ApiKeyAuth: []
+      parameters:
+        - name: sandbox_id
+          in: path
+          required: true
+          schema:
+            type: string
+            example: "bx-123abc"
+      responses:
+        '200':
+          description: Current Sandbox state
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SandboxResponse'
+
+  /sandbox/{sandbox_id}/stop:
+    post:
+      summary: Stop a Sandbox Compute pool
+      tags:
+        - Sandbox
+      security:
+        - ApiKeyAuth: []
+      parameters:
+        - name: sandbox_id
+          in: path
+          required: true
+          schema:
+            type: string
+            example: "bx-123abc"
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                grace:
+                  type: boolean
+                  default: true
+      responses:
+        '200':
+          description: Sandbox stopping
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SandboxResponse'
+
+  /job/{job_id}:
+    get:
+      summary: Get self-inference generation job status
+      security:
+        - ApiKeyAuth: []
+      parameters:
+        - name: job_id
+          in: path
+          required: true
+          schema:
+            type: string
+            example: "550e8400-e29b-41d4-a716-446655440000"
+      responses:
+        '200':
+          description: Generation job status or final generated asset
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  success:
+                    type: boolean
+                  status:
+                    type: string
+                    enum: [processing, done, failed]
+                  data:
+                    type: object
+                    additionalProperties: true
+                  message:
+                    type: string
+        '404':
+          description: Job not found
+
   /collection/{collection_id}/generate/text/:
     post:
       summary: Generate text using AI
@@ -2022,27 +2294,45 @@ paths:
           application/json:
             schema:
               type: object
-              required:
-                - prompt
+              description: Provide either `prompt` for inline text or `prompt_url` for a previously uploaded prompt file.
               properties:
                 prompt:
                   type: string
+                  description: Inline prompt text. Use for smaller prompts.
                   example: "Summarize the content of this video"
+                prompt_url:
+                  type: string
+                  description: URL to a previously uploaded plain-text prompt file. Use for larger prompts.
+                  example: "https://storage.googleapis.com/.../generate_text_prompt_123abc.txt"
                 video_id:
                   type: string
                   example: "m-12345"
                 model_name:
                   type: string
-                  example: "gpt-4"
+                  description: Hosted tier (`mini`, `basic`, `pro`, `ultra`) or self-hosted sandbox model name.
+                  example: "Qwen/Qwen3.5-27B"
+                sandbox_id:
+                  type: string
+                  description: Sandbox ID to use when `model_name` is a self-hosted model.
+                  example: "bx-123abc"
                 max_tokens:
                   type: integer
                   example: 500
                 temperature:
                   type: number
                   example: 0.7
+                model_config:
+                  type: object
+                  description: Additional self-hosted model configuration.
+                  additionalProperties: true
                 callback_url:
                   type: string
                   example: "https://webhook.example.com/callback"
+              oneOf:
+                - required:
+                    - prompt
+                - required:
+                    - prompt_url
       responses:
         '200':
           description: Text generation started or completed
@@ -5587,6 +5877,8 @@ tags:
     description: Content search and indexing
   - name: AI Generation
     description: AI-powered content generation
+  - name: Sandbox
+    description: Dedicated compute lifecycle for supported open-weight models
   - name: Billing
     description: Billing and usage management
   - name: RTStream
@@ -5602,4 +5894,4 @@ tags:
   - name: Transcode
     description: Media transcoding operations
   - name: Assets
-    description: Cross-collection asset listing
\ No newline at end of file
+    description: Cross-collection asset listing
diff --git a/videodb/__about__.py b/videodb/__about__.py
index 7f103dd..85bca94 100644
--- a/videodb/__about__.py
+++ b/videodb/__about__.py
@@ -2,7 +2,7 @@
 
 
 
-__version__ = "0.5.0"
+__version__ = "0.5.1"
 __title__ = "videodb"
 __author__ = "videodb"
 __email__ = "contact@videodb.io"
diff --git a/videodb/__init__.py b/videodb/__init__.py
index b736c88..79293de 100644
--- a/videodb/__init__.py
+++ b/videodb/__init__.py
@@ -25,10 +25,15 @@
     ReframeMode,
     SegmentationType,
     RTStreamChannelType,
+    SandboxTier,
+    SandboxStatus,
 )
 from videodb.client import Connection
 from videodb.search import AskResponse, SearchResponse, SearchResult
 from videodb.understanding import Understanding, UnderstandingAnalyzer
+from videodb.job import GenerationJob
+from videodb.sandbox import Sandbox
+from videodb.voice_clone import VoiceClone
 from videodb.capture_session import CaptureSession
 from videodb.websocket_client import WebSocketConnection
 from videodb.capture import CaptureClient, Channel, AudioChannel, VideoChannel, Channels, ChannelList
@@ -46,6 +51,9 @@
 __all__ = [
     "connect",
     "CaptureSession",
+    "GenerationJob",
+    "Sandbox",
+    "VoiceClone",
     "WebSocketConnection",
     "CaptureClient",
     "Channel",
@@ -82,6 +90,8 @@
     "ReframeMode",
     "SegmentationType",
     "RTStreamChannelType",
+    "SandboxTier",
+    "SandboxStatus",
 ]
 
 
diff --git a/videodb/_constants.py b/videodb/_constants.py
index cdfcb5c..1a1cde8 100644
--- a/videodb/_constants.py
+++ b/videodb/_constants.py
@@ -140,11 +140,36 @@ class ApiPath:
     token = "token"
     websocket = "websocket"
     export = "export"
+    job = "job"
+    sandbox = "sandbox"
+    voice_clone = "voice_clone"
+    understand = "understand"
+    indexes = "indexes"
+    identities = "identities"
+    merge = "merge"
+    split = "split"
+    async_response = "async-response"
+
 
 
 class Status:
     processing = "processing"
     in_progress = "in progress"
+    complete = "complete"
+
+
+class SandboxTier:
+    small = "small"
+    medium = "medium"
+
+
+class SandboxStatus:
+    provisioning = "provisioning"
+    active = "active"
+    stopping = "stopping"
+    stopped = "stopped"
+    failed = "failed"
+    alert = "alert"
 
 
 INDEX_TERMINAL_STATUSES = {"ready", "failed"}
@@ -164,10 +189,14 @@ class HttpClientDefaultValues:
     timeout = 30
     backoff_factor = 0.1
     status_forcelist = [502, 503, 504]
+    max_poll_time = 500
+    poll_interval = 5
 
 
 class MaxSupported:
     fade_duration = 5
+    # Prompts larger than this are uploaded as files instead of sent inline
+    generate_text_payload_size = 250 * 1024
 
 
 class SubtitleBorderStyle:
diff --git a/videodb/_upload.py b/videodb/_upload.py
index 0291abe..0a25e5d 100644
--- a/videodb/_upload.py
+++ b/videodb/_upload.py
@@ -1,9 +1,9 @@
-import requests
-
-from typing import Optional
+import os
+from typing import Optional, Union
 from urllib.parse import urlparse
+
+import requests
 from requests import HTTPError
-import os
 
 
 from videodb._constants import (
@@ -20,6 +20,31 @@ def _is_url(path: str) -> bool:
     return all([parsed.scheme in ("http", "https"), parsed.netloc])
 
 
+def upload_bytes(
+    _connection,
+    content: Union[str, bytes],
+    name: str,
+    content_type: str = "application/octet-stream",
+    collection_id: Optional[str] = None,
+) -> str:
+    """Upload in-memory content using a presigned upload URL and return the object URL."""
+    collection_id = collection_id or _connection.collection_id
+    upload_url_data = _connection.get(
+        path=f"{ApiPath.collection}/{collection_id}/{ApiPath.upload_url}",
+        params={"name": name},
+    )
+    upload_url = upload_url_data.get("upload_url")
+
+    try:
+        files = {"file": (name, content, content_type)}
+        response = requests.post(upload_url, files=files)
+        response.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        raise VideodbError("Error while uploading content", cause=e)
+
+    return upload_url
+
+
 def upload(
     _connection,
     source: Optional[str] = None,
@@ -71,16 +96,13 @@ def upload(
     if file_path:
         try:
             name = os.path.splitext(os.path.basename(file_path))[0] if not name else name
-            upload_url_data = _connection.get(
-                path=f"{ApiPath.collection}/{collection_id}/{ApiPath.upload_url}",
-                params={"name": name},
-            )
-            upload_url = upload_url_data.get("upload_url")
             with open(file_path, "rb") as file:
-                files = {"file": (name, file)}
-                response = requests.post(upload_url, files=files)
-                response.raise_for_status()
-                url = upload_url
+                url = upload_bytes(
+                    _connection=_connection,
+                    content=file,
+                    name=name,
+                    collection_id=collection_id,
+                )
 
         except FileNotFoundError as e:
             raise VideodbError("File not found", cause=e)
diff --git a/videodb/_utils/_http_client.py b/videodb/_utils/_http_client.py
index ab571f6..973cb8b 100644
--- a/videodb/_utils/_http_client.py
+++ b/videodb/_utils/_http_client.py
@@ -1,8 +1,8 @@
 """Http client Module."""
 
 import logging
+import time
 import requests
-import backoff
 
 from tqdm import tqdm
 from typing import (
@@ -65,6 +65,8 @@ def __init__(
         self.base_url = base_url
         self.show_progress = False
         self.progress_bar = None
+        self.max_poll_time = HttpClientDefaultValues.max_poll_time
+        self.poll_interval = HttpClientDefaultValues.poll_interval
         logger.debug(f"Initialized http client with base url: {self.base_url}")
 
     def _make_request(
@@ -73,6 +75,7 @@ def _make_request(
         path: str,
         base_url: Optional[str] = None,
         headers: Optional[dict] = None,
+        wait: bool = True,
         **kwargs,
     ):
         """Make a request to the api
@@ -81,6 +84,7 @@ def _make_request(
         :param str path: The path to make the request to
         :param str base_url: (optional) The base url to use for the request
         :param dict headers: (optional) The headers to use for the request
+        :param bool wait: If False, return raw data without polling (default True)
         :param kwargs: The keyword arguments to pass to the request method
         :return: json response from the request
         """
@@ -90,6 +94,11 @@ def _make_request(
             request_headers = {**self.session.headers, **(headers or {})}
             response = method(url, headers=request_headers, timeout=timeout, **kwargs)
             response.raise_for_status()
+            if not wait:
+                data = response.json().get("data")
+                if data is not None:
+                    return data
+                return response.json()
             return self._parse_response(response)
 
         except requests.exceptions.RequestException as e:
@@ -133,23 +142,33 @@ def _handle_request_error(self, e: requests.exceptions.RequestException) -> None
                 f"Invalid request: {str(e)}", e.response
             ) from None
 
-    @backoff.on_exception(
-        backoff.constant, Exception, max_time=500, interval=5, logger=None, jitter=None
-    )
     def _get_output(self, url: str):
-        """Get the output from an async request"""
-        response_json = self.session.get(url).json()
-        if (
-            response_json.get("status") == Status.in_progress
-            or response_json.get("status") == Status.processing
-        ):
+        """Poll an output URL until the job completes or times out."""
+        start = time.monotonic()
+        while True:
+            response_json = self.session.get(
+                url, timeout=HttpClientDefaultValues.timeout
+            ).json()
+            status = response_json.get("status")
+            if status not in (Status.in_progress, Status.processing):
+                break
+
             percentage = response_json.get("data", {}).get("percentage")
             if percentage and self.show_progress and self.progress_bar:
                 self.progress_bar.n = int(percentage)
                 self.progress_bar.update(0)
 
-            logger.debug("Waiting for processing to complete")
-            raise Exception("Stuck on processing status") from None
+            elapsed = time.monotonic() - start
+            if elapsed >= self.max_poll_time:
+                raise RequestTimeoutError(
+                    f"Polling timed out after {int(elapsed)}s "
+                    f"(max_poll_time={self.max_poll_time})",
+                    None,
+                )
+
+            logger.debug("Waiting for processing to complete (%.0fs elapsed)", elapsed)
+            time.sleep(self.poll_interval)
+
         if self.show_progress and self.progress_bar:
             self.progress_bar.n = 100
             self.progress_bar.update(0)
@@ -209,19 +228,31 @@ def _format_headers(self, headers: dict):
             formatted_headers[f"x-{key}"] = value
         return formatted_headers
 
+    def _apply_poll_overrides(self, kwargs):
+        """Extract and apply per-call poll overrides from kwargs."""
+        self.max_poll_time = kwargs.pop(
+            "max_poll_time", HttpClientDefaultValues.max_poll_time
+        )
+        self.poll_interval = kwargs.pop(
+            "poll_interval", HttpClientDefaultValues.poll_interval
+        )
+
     def get(
-        self, path: str, show_progress: Optional[bool] = False, **kwargs
+        self, path: str, show_progress: Optional[bool] = False, wait: bool = True, **kwargs
     ) -> requests.Response:
         """Make a get request"""
         self.show_progress = show_progress
-        return self._make_request(method=self.session.get, path=path, **kwargs)
+        self._apply_poll_overrides(kwargs)
+        return self._make_request(method=self.session.get, path=path, wait=wait, **kwargs)
 
     def post(
-        self, path: str, data=None, show_progress: Optional[bool] = False, **kwargs
+        self, path: str, data=None, show_progress: Optional[bool] = False,
+        wait: bool = True, **kwargs,
     ) -> requests.Response:
         """Make a post request"""
         self.show_progress = show_progress
-        return self._make_request(self.session.post, path, json=data, **kwargs)
+        self._apply_poll_overrides(kwargs)
+        return self._make_request(self.session.post, path, json=data, wait=wait, **kwargs)
 
     def put(self, path: str, data=None, **kwargs) -> requests.Response:
         """Make a put request"""
diff --git a/videodb/client.py b/videodb/client.py
index 7eac7bb..e53374d 100644
--- a/videodb/client.py
+++ b/videodb/client.py
@@ -1,4 +1,5 @@
 import logging
+import requests
 
 from typing import (
     Optional,
@@ -11,6 +12,7 @@
     TranscodeMode,
     VideoConfig,
     AudioConfig,
+    HttpClientDefaultValues,
 )
 
 from videodb.collection import Collection
@@ -19,6 +21,8 @@
 from videodb.audio import Audio
 from videodb.image import Image
 from videodb.meeting import Meeting
+from videodb.sandbox import Sandbox
+from videodb.voice_clone import VoiceClone
 from videodb.capture_session import CaptureSession
 from videodb.websocket_client import WebSocketConnection
 
@@ -264,6 +268,182 @@ def get_transcode_details(self, job_id: str) -> dict:
         """
         return self.get(path=f"{ApiPath.transcode}/{job_id}")
 
+    def get_job_status(self, job_id: str) -> dict:
+        """Get status/details for a self-inference generation job.
+
+        This preserves and normalizes the job response wrapper instead of using
+        the standard SDK response parser, because callers need the top-level
+        job status while polling.
+
+        :param str job_id: ID of the generation job
+        :return: Normalized job response with success, status, data, message
+        :rtype: dict
+        """
+        try:
+            url = f"{self.base_url}/{ApiPath.job}/{job_id}"
+            response = self.session.get(url, timeout=HttpClientDefaultValues.timeout)
+            response.raise_for_status()
+            response_json = response.json()
+        except requests.exceptions.RequestException as e:
+            self._handle_request_error(e)
+        except ValueError:
+            from videodb.exceptions import InvalidRequestError
+
+            raise InvalidRequestError("Invalid request: Unable to parse job response") from None
+
+        data = response_json.get("data") or {}
+        status = response_json.get("status") or data.get("status")
+        success = response_json.get("success", False)
+
+        if not status:
+            status = "done" if success else "failed"
+
+        return {
+            "success": success,
+            "status": status,
+            "data": data,
+            "message": response_json.get("message"),
+        }
+
+    def wait_for_job(
+        self,
+        job_id: str,
+        timeout: int = 600,
+        interval: int = 5,
+        result_type: str = None,
+    ):
+        """Poll a self-inference generation job until completion.
+
+        :param str job_id: ID of the generation job
+        :param int timeout: Maximum seconds to wait
+        :param int interval: Seconds between polls
+        :param str result_type: Optional expected result type, "audio" or "image"
+        :return: Generated SDK asset or final job data
+        """
+        from videodb.job import GenerationJob
+
+        return GenerationJob(
+            self, job_id=job_id, result_type=result_type
+        ).wait(timeout=timeout, interval=interval)
+
+    def create_sandbox(
+        self,
+        tier: Optional[str] = None,
+        name: Optional[str] = None,
+        callback_url: Optional[str] = None,
+        model_categories: Optional[List[str]] = None,
+        models: Optional[List[str]] = None,
+    ) -> "Sandbox":
+        """Create a new sandbox (GPU compute pool).
+
+        :param str tier: Sandbox tier — "small" or "medium" (default: server decides)
+        :param str name: Human-readable name (auto-generated if not provided)
+        :param str callback_url: URL to receive sandbox lifecycle webhooks
+        :param list[str] model_categories: Model categories to prepare for this sandbox, e.g. ``["vlm", "image_generation"]`` (optional)
+        :param list[str] models: Specific model names to prepare for this sandbox (optional)
+        :return: :class:`Sandbox <Sandbox>` object in provisioning state
+        :rtype: :class:`videodb.sandbox.Sandbox`
+        """
+        data = self.post(
+            path=ApiPath.sandbox,
+            data={
+                "tier": tier,
+                "name": name,
+                "callback_url": callback_url,
+                "model_categories": model_categories,
+                "models": models,
+            },
+        )
+        return Sandbox(self, **(data or {}))
+
+    def get_sandbox(self, sandbox_id: str) -> "Sandbox":
+        """Get a sandbox by ID.
+
+        :param str sandbox_id: The sandbox ID
+        :return: :class:`Sandbox <Sandbox>` object
+        :rtype: :class:`videodb.sandbox.Sandbox`
+        """
+        data = self.get(path=f"{ApiPath.sandbox}/{sandbox_id}")
+        return Sandbox(self, **(data or {}))
+
+    def list_sandboxes(
+        self,
+        status: Optional[str] = None,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> List["Sandbox"]:
+        """List all sandboxes, optionally filtered by status.
+
+        :param str status: Filter by sandbox status (optional)
+        :param int page: Page number (default: 1)
+        :param int page_size: Sandboxes per page (default: 20, maximum: 100)
+        :return: List of :class:`Sandbox <Sandbox>` objects
+        :rtype: list[:class:`videodb.sandbox.Sandbox`]
+        """
+        params = {"page": page, "page_size": page_size}
+        if status:
+            params["status"] = status
+        data = self.get(path=ApiPath.sandbox, params=params)
+        sandboxes_data = (data or {}).get("sandboxes", [])
+        return [Sandbox(self, **s) for s in sandboxes_data]
+
+    def create_voice_clone(
+        self,
+        ref_audio_id: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        ref_text: Optional[str] = None,
+        language: Optional[str] = None,
+        collection_id: Optional[str] = None,
+    ) -> "VoiceClone":
+        """Create a reusable voice clone from an existing audio asset.
+
+        :param str ref_audio_id: Source audio ID to use as the voice reference.
+        :param str name: Human-readable name (optional).
+        :param str description: Description (optional).
+        :param str ref_text: Text spoken in the reference audio (optional).
+        :param str language: Language code, e.g. ``"en"`` (optional).
+        :param str collection_id: Collection associated with the source audio (optional).
+        :return: :class:`VoiceClone <VoiceClone>` object.
+        :rtype: :class:`videodb.voice_clone.VoiceClone`
+        """
+        data = self.post(
+            path=ApiPath.voice_clone,
+            data={
+                "ref_audio_id": ref_audio_id,
+                "name": name,
+                "description": description,
+                "ref_text": ref_text,
+                "language": language,
+                "collection_id": collection_id,
+            },
+        )
+        return VoiceClone(self, **(data or {}))
+
+    def get_voice_clone(self, voice_clone_id: str) -> "VoiceClone":
+        """Get a voice clone by ID."""
+        data = self.get(path=f"{ApiPath.voice_clone}/{voice_clone_id}")
+        return VoiceClone(self, **(data or {}))
+
+    def list_voice_clones(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        language: Optional[str] = None,
+    ) -> List["VoiceClone"]:
+        """List voice clones for the current user."""
+        params = {"page": page, "page_size": page_size}
+        if language:
+            params["language"] = language
+        data = self.get(path=ApiPath.voice_clone, params=params)
+        voice_clones = (data or {}).get("voice_clones", [])
+        return [VoiceClone(self, **v) for v in voice_clones]
+
+    def delete_voice_clone(self, voice_clone_id: str) -> None:
+        """Delete a voice clone by ID."""
+        self.delete(path=f"{ApiPath.voice_clone}/{voice_clone_id}")
+        return None
+
     def upload(
         self,
         source: Optional[str] = None,
@@ -494,3 +674,12 @@ def generate_client_token(self, expires_in: int = 86400) -> str:
             data={"expires_in": expires_in},
         )
         return response.get("token")
+
+    def get_async_response(self, id: str) -> dict:
+        """Get the details of an async response.
+
+        :param str id: ID of the async response
+        :return: Details of the async response
+        :rtype: dict
+        """
+        return self.get(path=f"{ApiPath.async_response}/{id}", wait=False)
diff --git a/videodb/collection.py b/videodb/collection.py
index 6414080..a36966f 100644
--- a/videodb/collection.py
+++ b/videodb/collection.py
@@ -1,12 +1,16 @@
+import json
 import logging
+import uuid
 
 from typing import Optional, Union, List, Dict, Any, Literal, Tuple
 from videodb._upload import (
     upload,
+    upload_bytes,
 )
 from videodb._constants import (
     ApiPath,
     IndexType,
+    MaxSupported,
     MediaType,
     SearchType,
     _InternalSearchType,
@@ -14,6 +18,8 @@
 from videodb.video import Video
 from videodb.audio import Audio
 from videodb.image import Image
+from videodb.job import GenerationJob
+from videodb.voice_clone import VoiceClone
 from videodb.meeting import Meeting
 from videodb.capture_session import CaptureSession
 from videodb.rtstream import RTStream, RTStreamSearchResult, RTStreamShot
@@ -139,6 +145,54 @@ def delete_audio(self, audio_id: str) -> None:
             path=f"{ApiPath.audio}/{audio_id}", params={"collection_id": self.id}
         )
 
+    def create_voice_clone(
+        self,
+        ref_audio_id: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        ref_text: Optional[str] = None,
+        language: Optional[str] = None,
+    ) -> VoiceClone:
+        """Create a reusable voice clone from an audio in this collection.
+
+        :param str ref_audio_id: Source audio ID to use as the voice reference.
+        :param str name: Human-readable name (optional).
+        :param str description: Description (optional).
+        :param str ref_text: Text spoken in the reference audio (optional).
+        :param str language: Language code, e.g. ``"en"`` (optional).
+        :return: :class:`VoiceClone <VoiceClone>` object.
+        :rtype: :class:`videodb.voice_clone.VoiceClone`
+        """
+        return self._connection.create_voice_clone(
+            ref_audio_id=ref_audio_id,
+            name=name,
+            description=description,
+            ref_text=ref_text,
+            language=language,
+            collection_id=self.id,
+        )
+
+    def get_voice_clone(self, voice_clone_id: str) -> VoiceClone:
+        """Get a voice clone by ID."""
+        return self._connection.get_voice_clone(voice_clone_id)
+
+    def list_voice_clones(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        language: Optional[str] = None,
+    ) -> List[VoiceClone]:
+        """List user voice clones, optionally filtered by language."""
+        return self._connection.list_voice_clones(
+            page=page,
+            page_size=page_size,
+            language=language,
+        )
+
+    def delete_voice_clone(self, voice_clone_id: str) -> None:
+        """Delete a voice clone by ID."""
+        return self._connection.delete_voice_clone(voice_clone_id)
+
     def get_images(self) -> List[Image]:
         """Get all the images in the collection.
 
@@ -280,25 +334,51 @@ def generate_image(
         prompt: str,
         aspect_ratio: Optional[Literal["1:1", "9:16", "16:9", "4:3", "3:4"]] = "1:1",
         callback_url: Optional[str] = None,
-    ) -> Image:
+        model_name: Optional[str] = None,
+        config: Optional[dict] = None,
+        sandbox_id: Optional[str] = None,
+        wait: bool = False,
+        poll_interval: int = 5,
+        timeout: int = 600,
+    ) -> Union[Image, GenerationJob]:
         """Generate an image from a prompt.
 
         :param str prompt: Prompt for the image generation
-        :param str aspect_ratio: Aspect ratio of the image (optional)
+        :param str aspect_ratio: Aspect ratio of the image (optional, hosted models)
         :param str callback_url: URL to receive the callback (optional)
-        :return: :class:`Image <Image>` object
-        :rtype: :class:`videodb.image.Image`
+        :param str model_name: Model name. Use ``"black-forest-labs/FLUX.1-dev"`` for FLUX self-inference.
+        :param dict config: Model configuration. Used by FLUX.
+        :param str sandbox_id: ID of the sandbox to route the self-inference job to (optional).
+        :param bool wait: If True, wait for self-inference jobs and return Image.
+        :param int poll_interval: Seconds between job polls when wait=True.
+        :param int timeout: Maximum seconds to wait when wait=True.
+        :return: :class:`Image <Image>` or :class:`GenerationJob <GenerationJob>`
+        :rtype: Union[:class:`videodb.image.Image`, :class:`videodb.job.GenerationJob`]
         """
+        payload = {
+            "prompt": prompt,
+            "aspect_ratio": aspect_ratio,
+            "callback_url": callback_url,
+        }
+        if model_name:
+            payload["model_name"] = model_name
+        if config is not None:
+            payload["config"] = config
+        if sandbox_id:
+            payload["sandbox_id"] = sandbox_id
+
         image_data = self._connection.post(
             path=f"{ApiPath.collection}/{self.id}/{ApiPath.generate}/{ApiPath.image}",
-            data={
-                "prompt": prompt,
-                "aspect_ratio": aspect_ratio,
-                "callback_url": callback_url,
-            },
+            data=payload,
         )
-        if image_data:
-            return Image(self._connection, **image_data)
+        if not image_data:
+            return None
+        if image_data.get("job_id"):
+            job = GenerationJob.from_data(
+                self._connection, image_data, result_type="image"
+            )
+            return job.wait(timeout=timeout, interval=poll_interval) if wait else job
+        return Image(self._connection, **image_data)
 
     def generate_music(
         self, prompt: str, duration: int = 5, callback_url: Optional[str] = None
@@ -358,28 +438,55 @@ def generate_voice(
         voice_name: str = "Default",
         config: dict = {},
         callback_url: Optional[str] = None,
-    ) -> Audio:
+        model_name: str = "elevenlabs",
+        sandbox_id: Optional[str] = None,
+        voice_clone_id: Optional[str] = None,
+        clone_voice_id: Optional[str] = None,
+        wait: bool = False,
+        poll_interval: int = 5,
+        timeout: int = 600,
+    ) -> Union[Audio, GenerationJob]:
         """Generate voice from text.
 
         :param str text: Text to convert to voice
         :param str voice_name: Name of the voice to use
         :param dict config: Configuration for the voice generation
         :param str callback_url: URL to receive the callback (optional)
-        :return: :class:`Audio <Audio>` object
-        :rtype: :class:`videodb.audio.Audio`
+        :param str model_name: Model name. Use ``"k2-fsa/OmniVoice"`` for OmniVoice.
+        :param str sandbox_id: ID of the sandbox to route the self-inference job to (optional).
+        :param str voice_clone_id: ID of a reusable voice clone to use for OmniVoice (optional).
+        :param str clone_voice_id: Alias for ``voice_clone_id`` (optional).
+        :param bool wait: If True, wait for self-inference jobs and return Audio.
+        :param int poll_interval: Seconds between job polls when wait=True.
+        :param int timeout: Maximum seconds to wait when wait=True.
+        :return: :class:`Audio <Audio>` or :class:`GenerationJob <GenerationJob>`
+        :rtype: Union[:class:`videodb.audio.Audio`, :class:`videodb.job.GenerationJob`]
         """
+        if voice_clone_id and clone_voice_id and voice_clone_id != clone_voice_id:
+            raise ValueError("voice_clone_id and clone_voice_id cannot both be different")
+        resolved_voice_clone_id = voice_clone_id or clone_voice_id
+
         audio_data = self._connection.post(
             path=f"{ApiPath.collection}/{self.id}/{ApiPath.generate}/{ApiPath.audio}",
             data={
                 "text": text,
                 "audio_type": "voice",
                 "voice_name": voice_name,
+                "model_name": model_name,
                 "config": config,
                 "callback_url": callback_url,
+                "sandbox_id": sandbox_id,
+                "voice_clone_id": resolved_voice_clone_id,
             },
         )
-        if audio_data:
-            return Audio(self._connection, **audio_data)
+        if not audio_data:
+            return None
+        if audio_data.get("job_id"):
+            job = GenerationJob.from_data(
+                self._connection, audio_data, result_type="audio"
+            )
+            return job.wait(timeout=timeout, interval=poll_interval) if wait else job
+        return Audio(self._connection, **audio_data)
 
     def generate_video(
         self,
@@ -423,25 +530,69 @@ def generate_video(
     def generate_text(
         self,
         prompt: str,
-        model_name: Literal["basic", "pro", "ultra"] = "basic",
+        model_name: str = "basic",
         response_type: Literal["text", "json"] = "text",
+        wait: bool = True,
+        callback_url: Optional[str] = None,
+        sandbox_id: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        model_config: Optional[Dict[str, Any]] = None,
     ) -> Union[str, dict]:
         """Generate text from a prompt using genai offering.
 
+        Small prompts are sent inline as JSON. When the serialized request body
+        approaches the observed gateway limit (~256 KB), the prompt is uploaded
+        via the collection presigned upload URL and referenced as ``prompt_url``
+        to avoid API Gateway/Lambda payload size limits.
+
         :param str prompt: Prompt for the text generation
-        :param str model_name: Model name to use ("basic", "pro" or "ultra")
+        :param str model_name: Model name to use ("basic", "pro", "ultra", or a self-hosted model)
         :param str response_type: Desired response type ("text" or "json")
-        :return: Generated text response
+        :param bool wait: Wait for the text generation to complete (default: True)
+        :param str callback_url: URL to receive the callback (optional)
+        :param str sandbox_id: Sandbox ID to use for self-hosted models (optional)
+        :param int max_tokens: Maximum tokens to generate (optional)
+        :param float temperature: Sampling temperature (optional)
+        :param dict model_config: Additional self-hosted model configuration (optional)
+        :return: Generated text response when wait is True, otherwise the
+            asynchronous response data
         :rtype: Union[str, dict]
         """
+        payload = {
+            "prompt": prompt,
+            "model_name": model_name,
+            "response_type": response_type,
+            "callback_url": callback_url,
+            "sandbox_id": sandbox_id,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "model_config": model_config,
+        }
 
-        return self._connection.post(
-            path=f"{ApiPath.collection}/{self.id}/{ApiPath.generate}/{ApiPath.text}",
-            data={
-                "prompt": prompt,
+        payload_size = len(json.dumps(payload).encode("utf-8"))
+        if payload_size > MaxSupported.generate_text_payload_size:
+            payload = {
+                "prompt_url": upload_bytes(
+                    _connection=self._connection,
+                    content=prompt,
+                    name=f"generate_text_prompt_{uuid.uuid4().hex}.txt",
+                    content_type="text/plain; charset=utf-8",
+                    collection_id=self.id,
+                ),
                 "model_name": model_name,
                 "response_type": response_type,
-            },
+                "callback_url": callback_url,
+                "sandbox_id": sandbox_id,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "model_config": model_config,
+            }
+
+        return self._connection.post(
+            path=f"{ApiPath.collection}/{self.id}/{ApiPath.generate}/{ApiPath.text}",
+            data=payload,
+            wait=wait,
         )
 
     def dub_video(
diff --git a/videodb/editor.py b/videodb/editor.py
index 1dec1e8..85f0981 100644
--- a/videodb/editor.py
+++ b/videodb/editor.py
@@ -1,12 +1,12 @@
 import json
 import logging
-import requests
 import warnings
 
 from typing import List, Optional, Union
 from enum import Enum
 
 from videodb._constants import ApiPath
+from videodb._upload import upload_bytes
 from videodb._utils._video import build_iframe_embed_code
 from videodb.exceptions import InvalidRequestError
 
@@ -1148,26 +1148,20 @@ def _upload_timeline_data(self, json_str: str) -> str:
         :rtype: str
         :raises InvalidRequestError: If upload fails
         """
-        # Get a presigned upload URL
-        upload_url_data = self.connection.get(
-            path=f"{ApiPath.collection}/{self.connection.collection_id}/{ApiPath.upload_url}",
-            params={"name": "timeline_data.json"},
-        )
-        upload_url = upload_url_data.get("upload_url")
-
-        # Upload the JSON data as a file
         try:
-            files = {"file": ("timeline_data.json", json_str, "application/json")}
-            response = requests.post(upload_url, files=files)
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
+            return upload_bytes(
+                _connection=self.connection,
+                content=json_str,
+                name="timeline_data.json",
+                content_type="application/json",
+                collection_id=self.connection.collection_id,
+            )
+        except Exception as e:
             raise InvalidRequestError(
                 f"Failed to upload timeline data: {str(e)}",
                 getattr(e, "response", None),
             ) from None
 
-        return upload_url
-
     def download_stream(self, stream_url: str) -> dict:
         """Download a stream from the timeline.
 
diff --git a/videodb/job.py b/videodb/job.py
new file mode 100644
index 0000000..f0ba7c4
--- /dev/null
+++ b/videodb/job.py
@@ -0,0 +1,111 @@
+import time
+from typing import Optional
+
+from videodb.audio import Audio
+from videodb.image import Image
+from videodb.exceptions import InvalidRequestError, RequestTimeoutError
+
+
+class GenerationJob:
+    """A self-inference generation job.
+
+    OmniVoice text-to-speech and FLUX image generation return a VideoDB job
+    after the initial server-side async task has dispatched work to
+    inference-core. Use :meth:`wait` to poll until the final asset is ready.
+    """
+
+    def __init__(
+        self,
+        connection,
+        job_id: str,
+        output_url: Optional[str] = None,
+        status: str = "processing",
+        result_type: Optional[str] = None,
+        data: Optional[dict] = None,
+    ) -> None:
+        self._connection = connection
+        self.id = job_id
+        self.job_id = job_id
+        self.output_url = output_url
+        self.status = status or "processing"
+        self.result_type = result_type
+        self.data = data or {}
+
+    def __repr__(self) -> str:
+        return (
+            f"GenerationJob("
+            f"job_id={self.job_id}, "
+            f"status={self.status}, "
+            f"result_type={self.result_type})"
+        )
+
+    @classmethod
+    def from_data(cls, connection, data: dict, result_type: Optional[str] = None):
+        """Create a job from an API job payload."""
+        data = data or {}
+        job_id = data.get("job_id") or data.get("id")
+        if not job_id:
+            raise InvalidRequestError("Invalid generation job response: missing job_id")
+        job_type = data.get("job_type")
+        inferred_result_type = result_type
+        if not inferred_result_type:
+            if job_type == "tts":
+                inferred_result_type = "audio"
+            elif job_type == "image":
+                inferred_result_type = "image"
+        return cls(
+            connection=connection,
+            job_id=job_id,
+            output_url=data.get("output_url"),
+            status=data.get("status", "processing"),
+            result_type=inferred_result_type,
+            data=data,
+        )
+
+    def refresh(self):
+        """Refresh this job's status from VideoDB."""
+        job = self._connection.get_job_status(self.job_id)
+        self.status = job.get("status", self.status)
+        self.data = job.get("data") or {}
+        self.output_url = self.data.get("output_url", self.output_url)
+        if not self.result_type:
+            job_type = self.data.get("job_type")
+            if job_type == "tts":
+                self.result_type = "audio"
+            elif job_type == "image":
+                self.result_type = "image"
+        return self
+
+    def wait(self, timeout: int = 600, interval: int = 5):
+        """Poll this job until it completes and return the generated asset.
+
+        :param int timeout: Maximum seconds to wait
+        :param int interval: Seconds between polls
+        :return: :class:`Audio <videodb.audio.Audio>`,
+            :class:`Image <videodb.image.Image>`, or final job data if the
+            result type cannot be inferred
+        """
+        deadline = time.time() + timeout
+        while True:
+            self.refresh()
+            if self.status != "processing":
+                break
+            if time.time() >= deadline:
+                raise RequestTimeoutError(
+                    f"Generation job {self.job_id} did not complete within {timeout} seconds"
+                )
+            time.sleep(interval)
+
+        if self.status == "failed":
+            raise InvalidRequestError(f"Generation job {self.job_id} failed")
+
+        return self._to_asset()
+
+    def _to_asset(self):
+        data = self.data or {}
+        asset_id = data.get("id")
+        if self.result_type == "audio" or (asset_id and asset_id.startswith("a-")):
+            return Audio(self._connection, **data)
+        if self.result_type == "image" or (asset_id and asset_id.startswith("img-")):
+            return Image(self._connection, **data)
+        return data
diff --git a/videodb/rtstream.py b/videodb/rtstream.py
index 4c2a97a..93f1928 100644
--- a/videodb/rtstream.py
+++ b/videodb/rtstream.py
@@ -235,6 +235,7 @@ class RTStreamSceneIndex:
     :ivar str prompt: Prompt for scene extraction
     :ivar str name: Name of the scene index
     :ivar str status: Status of the scene index
+    :ivar str sandbox_id: Sandbox ID used for self-hosted inference
     """
 
     def __init__(
@@ -248,6 +249,7 @@ def __init__(
         self.prompt = kwargs.get("prompt", None)
         self.name = kwargs.get("name", None)
         self.status = kwargs.get("status", None)
+        self.sandbox_id = kwargs.get("sandbox_id", None)
 
     def __repr__(self) -> str:
         return (
@@ -258,7 +260,8 @@ def __repr__(self) -> str:
             f"extraction_config={self.extraction_config}, "
             f"prompt={self.prompt}, "
             f"name={self.name}, "
-            f"status={self.status})"
+            f"status={self.status}, "
+            f"sandbox_id={self.sandbox_id})"
         )
 
     def get_scenes(self, start: int = None, end: int = None, page=1, page_size=100):
@@ -811,6 +814,7 @@ def index_scenes(
         model_config={},
         name=None,
         ws_connection_id: Optional[str] = None,
+        sandbox_id: Optional[str] = None,
     ):
         """Index scenes from the rtstream.
 
@@ -821,6 +825,7 @@ def index_scenes(
         :param dict model_config: Configuration for the model
         :param str name: Name of the scene index
         :param str ws_connection_id: WebSocket connection ID for real-time updates (optional)
+        :param str sandbox_id: ID of the sandbox to route self-hosted inference to (optional)
         :return: Scene index, :class:`RTStreamSceneIndex <RTStreamSceneIndex>` object
         :rtype: :class:`videodb.rtstream.RTStreamSceneIndex`
         """
@@ -834,6 +839,8 @@ def index_scenes(
         }
         if ws_connection_id:
             data["ws_connection_id"] = ws_connection_id
+        if sandbox_id:
+            data["sandbox_id"] = sandbox_id
 
         index_data = self._connection.post(
             f"{ApiPath.rtstream}/{self.id}/{ApiPath.index}/{ApiPath.scene}",
@@ -850,6 +857,7 @@ def index_scenes(
             prompt=index_data.get("prompt"),
             name=index_data.get("name"),
             status=index_data.get("status"),
+            sandbox_id=index_data.get("sandbox_id"),
         )
 
     def index_spoken_words(
@@ -861,6 +869,7 @@ def index_spoken_words(
         model_config: dict = {},
         name: str = None,
         ws_connection_id: Optional[str] = None,
+        sandbox_id: Optional[str] = None,
     ):
         """Index spoken words from the rtstream transcript.
 
@@ -872,6 +881,7 @@ def index_spoken_words(
         :param dict model_config: Configuration for the model
         :param str name: Name of the spoken words index
         :param str ws_connection_id: WebSocket connection ID for real-time updates (optional)
+        :param str sandbox_id: ID of the sandbox to route self-hosted inference to (optional)
         :return: Scene index, :class:`RTStreamSceneIndex <RTStreamSceneIndex>` object
         :rtype: :class:`videodb.rtstream.RTStreamSceneIndex`
         """
@@ -890,6 +900,8 @@ def index_spoken_words(
         }
         if ws_connection_id:
             data["ws_connection_id"] = ws_connection_id
+        if sandbox_id:
+            data["sandbox_id"] = sandbox_id
 
         index_data = self._connection.post(
             f"{ApiPath.rtstream}/{self.id}/{ApiPath.index}/{ApiPath.scene}",
@@ -906,6 +918,7 @@ def index_spoken_words(
             prompt=index_data.get("prompt"),
             name=index_data.get("name"),
             status=index_data.get("status"),
+            sandbox_id=index_data.get("sandbox_id"),
         )
 
     def index_audio(
@@ -916,6 +929,7 @@ def index_audio(
         model_config: dict = {},
         name: str = None,
         ws_connection_id: Optional[str] = None,
+        sandbox_id: Optional[str] = None,
     ):
         """Index audio from the rtstream transcript.
 
@@ -927,6 +941,7 @@ def index_audio(
         :param dict model_config: Configuration for the model
         :param str name: Name of the audio index
         :param str ws_connection_id: WebSocket connection ID for real-time updates (optional)
+        :param str sandbox_id: ID of the sandbox to route self-hosted inference to (optional)
         :return: Scene index, :class:`RTStreamSceneIndex <RTStreamSceneIndex>` object
         :rtype: :class:`videodb.rtstream.RTStreamSceneIndex`
         """
@@ -948,6 +963,8 @@ def index_audio(
         }
         if ws_connection_id:
             data["ws_connection_id"] = ws_connection_id
+        if sandbox_id:
+            data["sandbox_id"] = sandbox_id
 
         index_data = self._connection.post(
             f"{ApiPath.rtstream}/{self.id}/{ApiPath.index}/{ApiPath.scene}",
@@ -964,6 +981,7 @@ def index_audio(
             prompt=index_data.get("prompt"),
             name=index_data.get("name"),
             status=index_data.get("status"),
+            sandbox_id=index_data.get("sandbox_id"),
         )
 
     def index_visuals(
@@ -974,6 +992,7 @@ def index_visuals(
         model_config: dict = {},
         name: str = None,
         ws_connection_id: Optional[str] = None,
+        sandbox_id: Optional[str] = None,
     ):
         """Index visuals (scenes) from the rtstream.
 
@@ -986,6 +1005,7 @@ def index_visuals(
         :param dict model_config: Configuration for the model
         :param str name: Name of the visual index
         :param str ws_connection_id: WebSocket connection ID for real-time updates (optional)
+        :param str sandbox_id: ID of the sandbox to route self-hosted inference to (optional)
         :return: Scene index, :class:`RTStreamSceneIndex <RTStreamSceneIndex>` object
         :rtype: :class:`videodb.rtstream.RTStreamSceneIndex`
         """
@@ -1007,6 +1027,8 @@ def index_visuals(
         }
         if ws_connection_id:
             data["ws_connection_id"] = ws_connection_id
+        if sandbox_id:
+            data["sandbox_id"] = sandbox_id
 
         index_data = self._connection.post(
             f"{ApiPath.rtstream}/{self.id}/{ApiPath.index}/{ApiPath.scene}",
@@ -1023,6 +1045,7 @@ def index_visuals(
             prompt=index_data.get("prompt"),
             name=index_data.get("name"),
             status=index_data.get("status"),
+            sandbox_id=index_data.get("sandbox_id"),
         )
 
     def list_scene_indexes(self):
@@ -1044,6 +1067,7 @@ def list_scene_indexes(self):
                 prompt=index.get("prompt"),
                 name=index.get("name"),
                 status=index.get("status"),
+                sandbox_id=index.get("sandbox_id"),
             )
             for index in index_data.get("scene_indexes", [])
         ]
@@ -1067,6 +1091,7 @@ def get_scene_index(self, index_id: str) -> RTStreamSceneIndex:
             prompt=index_data.get("prompt"),
             name=index_data.get("name"),
             status=index_data.get("status"),
+            sandbox_id=index_data.get("sandbox_id"),
         )
 
     def understand(
diff --git a/videodb/sandbox.py b/videodb/sandbox.py
new file mode 100644
index 0000000..8b3fabf
--- /dev/null
+++ b/videodb/sandbox.py
@@ -0,0 +1,129 @@
+import time
+
+from videodb._constants import ApiPath, SandboxStatus
+from videodb.exceptions import InvalidRequestError, RequestTimeoutError
+
+TERMINAL_STATUSES = (SandboxStatus.stopped, SandboxStatus.failed)
+READY_STATUSES = (SandboxStatus.active, SandboxStatus.alert)
+
+
+class Sandbox:
+    """A persistent GPU compute pool for running inference jobs."""
+
+    def __init__(
+        self,
+        _connection,
+        sandbox_id=None,
+        id=None,
+        tier=None,
+        status=None,
+        name=None,
+        created_at=None,
+        started_at=None,
+        stopped_at=None,
+        model_categories=None,
+        models=None,
+        region=None,
+        expires_at=None,
+        **kwargs,
+    ):
+        self._connection = _connection
+        self.id = sandbox_id or id
+        self.tier = tier
+        self.status = status
+        self.name = name
+        self.created_at = created_at
+        self.started_at = started_at
+        self.stopped_at = stopped_at
+        self.model_categories = model_categories or []
+        self.models = models or []
+        self.region = region
+        self.expires_at = expires_at
+
+    def __repr__(self):
+        return f"Sandbox(id={self.id}, tier={self.tier}, status={self.status}, name={self.name})"
+
+    def _update(self, data):
+        if not data:
+            return
+        self.id = data.get("sandbox_id", data.get("id", self.id))
+        self.tier = data.get("tier", self.tier)
+        self.status = data.get("status", self.status)
+        self.name = data.get("name", self.name)
+        self.created_at = data.get("created_at", self.created_at)
+        self.started_at = data.get("started_at", self.started_at)
+        self.stopped_at = data.get("stopped_at", self.stopped_at)
+        self.model_categories = data.get("model_categories", self.model_categories)
+        self.models = data.get("models", self.models)
+        self.region = data.get("region", self.region)
+        self.expires_at = data.get("expires_at", self.expires_at)
+
+    def refresh(self):
+        """Fetch latest sandbox state from the server."""
+        data = self._connection.get(path=f"{ApiPath.sandbox}/{self.id}")
+        self._update(data or {})
+        return self
+
+    def wait_for_ready(self, timeout=300, interval=5):
+        """Poll until the sandbox is active.
+
+        :param int timeout: Maximum seconds to wait (default 300)
+        :param int interval: Seconds between polls (default 5)
+        :return: self
+        :raises RequestTimeoutError: If timeout is exceeded
+        :raises InvalidRequestError: If sandbox enters a terminal state
+        """
+        deadline = time.time() + timeout
+        while True:
+            self.refresh()
+            if self.status in READY_STATUSES:
+                return self
+            if self.status in TERMINAL_STATUSES:
+                raise InvalidRequestError(
+                    f"Sandbox {self.id} entered terminal state: {self.status}"
+                )
+            if time.time() >= deadline:
+                raise RequestTimeoutError(
+                    f"Sandbox {self.id} not ready within {timeout}s"
+                )
+            time.sleep(interval)
+
+    def stop(self, grace=True):
+        """Stop this sandbox.
+
+        :param bool grace: Wait for running jobs to finish before teardown (default True)
+        :return: self
+        """
+        data = self._connection.post(
+            path=f"{ApiPath.sandbox}/{self.id}/stop",
+            data={"grace": grace},
+        )
+        self._update(data or {})
+        return self
+
+    def wait_for_stop(self, timeout=120, interval=5):
+        """Poll until the sandbox is stopped.
+
+        :param int timeout: Maximum seconds to wait (default 120)
+        :param int interval: Seconds between polls (default 5)
+        :return: self
+        :raises RequestTimeoutError: If timeout is exceeded
+        """
+        deadline = time.time() + timeout
+        while True:
+            self.refresh()
+            if self.status in TERMINAL_STATUSES:
+                return self
+            if time.time() >= deadline:
+                raise RequestTimeoutError(
+                    f"Sandbox {self.id} did not stop within {timeout}s"
+                )
+            time.sleep(interval)
+
+    @property
+    def is_active(self):
+        return self.status == SandboxStatus.active
+
+    @property
+    def is_ready(self):
+        return self.status in READY_STATUSES
diff --git a/videodb/scene.py b/videodb/scene.py
index 7bd651a..7affac4 100644
--- a/videodb/scene.py
+++ b/videodb/scene.py
@@ -64,12 +64,14 @@ def describe(
         prompt: Optional[str] = None,
         model_name: Optional[str] = None,
         model_config: Optional[Dict] = None,
+        sandbox_id: Optional[str] = None,
     ) -> None:
         """Describe the scene.
 
         :param str prompt: (optional) The prompt to use for the description
         :param str model_name: (optional) The model to use for the description
         :param dict model_config: (optional) The model configuration for the description
+        :param str sandbox_id: (optional) ID of the sandbox to route the job to
         :return: The description of the scene
         :rtype: str
         """
@@ -81,6 +83,7 @@ def describe(
                 "prompt": prompt,
                 "model_name": model_name,
                 "model_config": model_config,
+                "sandbox_id": sandbox_id,
             },
         )
         self.description = description_data.get("description", None)
diff --git a/videodb/video.py b/videodb/video.py
index 75cc8ae..c3e014f 100644
--- a/videodb/video.py
+++ b/videodb/video.py
@@ -780,6 +780,7 @@ def index_scenes(
         name: Optional[str] = None,
         scenes: Optional[List[Scene]] = None,
         callback_url: Optional[str] = None,
+        sandbox_id: Optional[str] = None,
     ) -> Optional[str]:
         """Index the scenes of the video.
 
@@ -806,6 +807,7 @@ def index_scenes(
         :param str name: (optional) The name of the scene index
         :param list[Scene] scenes: (optional) The scenes to be indexed, List of :class:`Scene <Scene>` objects
         :param str callback_url: (optional) The callback url
+        :param str sandbox_id: (optional) ID of the sandbox to route the job to
         :raises InvalidRequestError: If the index fails or index already exists
         :return: The scene index id
         :rtype: str
@@ -822,6 +824,7 @@ def index_scenes(
                 "name": name,
                 "scenes": [scene.to_json() for scene in scenes] if scenes else None,
                 "callback_url": callback_url,
+                "sandbox_id": sandbox_id,
             },
         )
         if not scenes_data:
@@ -836,6 +839,7 @@ def index_visuals(
         model_config: Optional[Dict] = None,
         name: Optional[str] = None,
         callback_url: Optional[str] = None,
+        sandbox_id: Optional[str] = None,
     ) -> Optional[str]:
         """Index visuals (scenes) from the video.
 
@@ -849,6 +853,7 @@ def index_visuals(
         :param dict model_config: Configuration for the model
         :param str name: Name of the visual index
         :param str callback_url: URL to receive the callback (optional)
+        :param str sandbox_id: ID of the sandbox to route the job to (optional)
         :return: The scene index id
         :rtype: str
         """
@@ -881,6 +886,7 @@ def index_visuals(
                 "model_config": model_config or {},
                 "name": name,
                 "callback_url": callback_url,
+                "sandbox_id": sandbox_id,
             },
         )
         if not scenes_data:
diff --git a/videodb/voice_clone.py b/videodb/voice_clone.py
new file mode 100644
index 0000000..130f116
--- /dev/null
+++ b/videodb/voice_clone.py
@@ -0,0 +1,65 @@
+class VoiceClone:
+    """Reusable cloned voice reference backed by a VideoDB audio asset."""
+
+    def __init__(
+        self,
+        _connection,
+        id=None,
+        voice_clone_id=None,
+        ref_audio_id=None,
+        ref_text=None,
+        name=None,
+        description=None,
+        language=None,
+        collection_id=None,
+        status=None,
+        created_at=None,
+        updated_at=None,
+        **kwargs,
+    ):
+        self._connection = _connection
+        self.id = voice_clone_id or id
+        self.ref_audio_id = ref_audio_id
+        self.ref_text = ref_text
+        self.name = name
+        self.description = description
+        self.language = language
+        self.collection_id = collection_id
+        self.status = status
+        self.created_at = created_at
+        self.updated_at = updated_at
+
+    def __repr__(self):
+        return (
+            f"VoiceClone(id={self.id}, name={self.name}, "
+            f"ref_audio_id={self.ref_audio_id}, status={self.status})"
+        )
+
+    def _update(self, data):
+        if not data:
+            return
+        self.id = data.get("voice_clone_id", data.get("id", self.id))
+        self.ref_audio_id = data.get("ref_audio_id", self.ref_audio_id)
+        self.ref_text = data.get("ref_text", self.ref_text)
+        self.name = data.get("name", self.name)
+        self.description = data.get("description", self.description)
+        self.language = data.get("language", self.language)
+        self.collection_id = data.get("collection_id", self.collection_id)
+        self.status = data.get("status", self.status)
+        self.created_at = data.get("created_at", self.created_at)
+        self.updated_at = data.get("updated_at", self.updated_at)
+
+    def refresh(self):
+        """Fetch latest voice clone state from the server."""
+        from videodb._constants import ApiPath
+
+        data = self._connection.get(path=f"{ApiPath.voice_clone}/{self.id}")
+        self._update(data or {})
+        return self
+
+    def delete(self):
+        """Delete this voice clone."""
+        from videodb._constants import ApiPath
+
+        self._connection.delete(path=f"{ApiPath.voice_clone}/{self.id}")
+        return None