What is Chalk?

Chalk is the AI/ML data platform, providing infrastructure in your own cloud for:

• Getting fresh, contextual data to your models and agents at inference time
• Deploying and running those models and agents securely and at scale

Chalk offers both the features/context and compute solutions for inference, built on the same philosophy: define what you need in Python, and run it on infrastructure you control.

​

Why Chalk?

Most teams assemble a production AI stack from a feature store, a vector database, retrieval and prompt tooling, an orchestration layer, a sandbox runtime, and a governance story — then fight to keep them all consistent. Chalk replaces that stack with a single platform:

• One definition of your data — features, embeddings, LLM outputs, and prompts are all just Python, computed once and served everywhere: training, real-time inference, and agents.
• Point-in-time correct — query any value as it existed at any moment, so training data matches production and agent evals replay exactly what production saw.
• Fast in production — features served in single-digit milliseconds, so real-time models and agents never wait on data.
• In your own cloud — everything runs in your VPC under IAM roles you control, so your security team evaluates the platform once instead of every agent you ship.

​

The Context Engine

The Context Engine is a real-time feature computation engine that serves as the single source of truth for your features. You define features once in Python, and Chalk computes and serves them directly from your data sources at inference time in milliseconds .

Unlike traditional feature stores, which behave like databases or caching layers, Chalk keeps training and serving perfectly in sync and makes feature development faster. It adds built-in monitoring, a branch-based deployment model for feature versioning, and deployment inside your own cloud. This is especially critical for teams working with sensitive data or in regulated industries.

Here’s a quick example of declarative feature engineering in Chalk:

from chalk.features import features
from chalk import online

@features
class User:
    id: int
    total_orders: int
    chargeback_rate: float
    fraud_score: float

@online
def score_fraud(
    orders: User.total_orders, cbr: User.chargeback_rate,
) -> User.fraud_score:
    return 0.7 * cbr + 0.3 * (orders < 3)

Query the same features in real time, or as of any point in the past for training and evaluation:

from chalk.client import ChalkClient

# in real time, or as-of any point in the past
ChalkClient().query(
    input={"user.id": 1},
    output=["user.fraud_score"]
)

​

Chalk Compute

Building on that same philosophy, Chalk Compute extends the platform to the context and infrastructure challenges of agents. It provides governed, sandboxed environments where agents securely run and take action on your data — without it ever leaving your VPC. That lets you run scalable agents (or any remote process) quickly, manage data access, and evaluate agent performance against historical time periods.

Here’s a simple example of spinning up a sandbox:

sandbox = Sandbox(
    cpu="2",
    memory="4Gi",
    image=(
        Image.debian_slim(python_version="3.13").run_commands("pip install claude")
    ),
    volumes=[("code", "/code")],
).run()

print(sandbox.exec("echo", "hello!").stdout_text)
sandbox.terminate()

Every sandbox is isolated under gVisor, launches with its own scoped cloud identity, and can be replayed against any point in time. Sandboxes boot in under a second and scale to 10,000 isolated containers in under 10 seconds. The same SDK also runs long-lived model servers — for example, a GPU-backed inference server:

import chalkcompute

# a GPU-backed model server, in your own cloud
server = chalkcompute.Container(
    image=chalkcompute.Image.base("vllm/vllm-openai:latest"),
    gpu="nvidia-l4:1", cpu="4", memory="16Gi", port=8000,
    entrypoint=["--model", "Qwen/Qwen2.5-7B-Instruct"],
)
server.run()

​

Get started

1. Install the SDK. pip install chalkpy for the Context Engine, and pip install chalkcompute to run agents and models.
2. Connect your cloud. Point Chalk at your account so everything runs in your VPC. Chalk Compute runs on AWS or GCP; the Context Engine also supports Azure.
3. Define your features. Write resolvers for the data your models and agents need, then chalk apply to deploy them.
4. Query them in real time, or backfill any feature as of any point in the past.
5. Run your agents. Decorate a Python function with @chalkcompute.function and invoke it remotely.

Next steps: read the docs overview, the feature engineering guide, the Chalk Compute overview, and the API reference.