Tilebox documentation

Start building with Tilebox

Query Earth Data. Build, run, debug, and scale geospatial workflows across environments. One API for humans and agents.

Agent
CLI
Python
Go

You

Build a reproducible Tilebox workflow that starts with a user-provided CSV of known data centers and then:

Finds cloud-free Sentinel-2 imagery over a target lat/lon in a time window
Reads the relevant band products and crops scenes to a 3km area around the target
Computes the cloud fraction for the cropped area and filters out scenes > 1%
Compares before/after by scoring visible change based on suitable metrics
Creates a datacenter site ranking based on score

Use the provided Tilebox skills to research datasets, access storage, outline the workflow, and then implement it. Deploy and run on our GCP cluster, in case of failures inspect runner logs and iterate on the workflow.

Ask your agent to build with Tilebox…↵

CLI

curl -fsSL https://cli.tilebox.com/install.sh | sh

tilebox dataset query
  open_data.copernicus.sentinel2_msi
  --last 7d
  --spatial-extent 'POLYGON((-109 41,-109 37,-102 37,-102 41,-109 41))'
  --limit 10

tilebox job submit
  --name "Datacenter Monitoring"
  --task "ComputeVisibleChange"
  --input "{\"before\": \"2024-06-01\", \"after\": \"2026-06-01\"}"
  --cluster gcp-Drv6L7Li4t7Yvk

runner.py

from tilebox.datasets import Client
from tilebox.workflows import ExecutionContext, Runner, Task

class ComputeVisibleChange(Task):
  before: str
  after: str

  def execute(self, context: ExecutionContext):
    sentinel2 = Client().dataset(
      "open_data.copernicus.sentinel2_msi"
    )
    scenes = sentinel2.collection("S2A_S2MSI1A").query(
        temporal_extent=(before, after),
    )
    context.logger.info("Found scenes", n=len(scenes.granule_name))
    context.submit_subtasks([
      ProcessScene(str(name) for name in scenes.granule_name)
    ])

runner = Runner(tasks=[ComputeVisibleChange])

main.go

type ComputeVisibleChange struct {
    Before time.Time
    After  time.Time
}

func (t *ComputeVisibleChange) Execute(ctx context.Context) error {
    client := datasets.NewClient()
    dataset, _ := client.Datasets.Get(ctx, "open_data.copernicus.sentinel2_msi")
    collection, _ := client.Collections.Get(ctx, dataset.ID, "S2A_S2MSI1C")

    var scenes []*examplesv1.Sentinel2Msi
    _ = client.Datapoints.QueryInto(ctx, dataset.ID, &scenes,
        datasets.WithCollections(collection),
        datasets.WithTemporalExtent(query.NewTimeInterval(t.Before, t.After)),
    )

    slog.InfoContext(ctx, "Found scenes", slog.Int("n", len(scenes)))
    for _, scene := range scenes {
        _, _ = workflows.SubmitSubtask(ctx, &ProcessScene{
            Name: scene.GetGranuleName(),
        })
    }
    return nil
}

Get started

Choose how you build

Use Tilebox directly as a developer, or give an agent the same tools and documentation context so it can operate Tilebox for you.

Agent connected to Earth data and workflow observability tools

Use an agent

Configure a coding agent with the Tilebox CLI, agent skills, and optional MCP access. Agents can inspect datasets, write workflow code, submit jobs, and debug runs with Tilebox context.

Onboard your agent Create and deploy workflows Connect with MCP

Developer terminal connected to code debugging and dataset tools

Build as a developer

Use the Console, Python SDK, Go SDK, and CLI to query data, ingest your own catalogs, create workflow tasks, and run them across your infrastructure.

Quickstart Choose an SDK API reference

Learn

Explore the platform

Start from the outcome you need. Tilebox combines typed data access, workflow execution on your infrastructure, and shared observability for people and agents working on geospatial systems.

Query satellite data

Search typed datasets by time, location, collection, or datapoint ID.

Inspect workflow runs

Use logs, traces, progress, and job state to debug workflows and verify results.

Deploy to your own compute

Connect runners to your own infrastructure and control where workflow tasks execute.

Browse practical recipes

Find task-focused guides for querying data, building workflows, connecting storage, and operating Tilebox.

Run a workflow

Connect storage

Ingest data

Sample notebooks

Spatio-temporal datasets

Jobs

Scale

From query to operational pipelines

Start with open data or your own catalogs, turn processing steps into tasks, and run them where your data and infrastructure already live.

Discover and query data

Query open datasets or your own custom Tilebox datasets by time, area of interest, collection, or datapoint ID.

Build workflow tasks

Turn processing steps into workflow tasks that can submit subtasks, report progress, use caches, and emit logs and traces.

Prototype locally

Develop with local runners, iterate quickly, and prototype your geospatial workflows.

Deploy to your own compute

Run workflows across cloud, on premise, sovereign, air-gapped, or edge environments while Tilebox tracks jobs and distributes work for parallel execution.

Inspect and iterate

Query job state, logs, spans, and progress from the Console, SDKs, CLI, or agent tools.