Tile: The building block of enterprise AI

Every era of computing has had its unit of data.

The file abstracted storage so a person could open, read, and close a document without thinking about disk blocks.

The table did the same for structured data — applications could query it without knowing the on-disk layout.

Both those data primitives were extraordinary, and both have lasted decades. But was either built for an AI agent?

An agent can read a file. Point one at a bucket, and it will guess the format, install what it needs, and return a result. Six months later, when a reviewer asks, none of it can be answered: which credential it used, whether it was entitled to what it read, how that result was produced. The guessing costs something too: a 100 GB genomics file or a DICOM study needs its own libraries, and the compute to run them next to the data — both found again on every call. And the file itself declares nothing: no interface to query, no policy to enforce, no index that would let anyone find it, no record of who touched it. That’s fine for a person opening a document, which is what the file was built for. It isn’t a foundation for systems that read on their own, at machine speed, on data someone is accountable for. To put enterprise data in front of an agent safely, you need a different primitive — one that carries the context and tooling an agent needs, and that can only be reached under the controls you already have. We built one. We call it the Tile.

Everything beyond those four comes from the platform, the same way for every Tile: search across all of them the moment one is created, governance through your existing identity provider with every access and query recorded, lineage (versions, relationships between Tiles, and data provenance), and access through the interfaces your users and agents already use — FUSE, SQL, SDK, REST, and MCP.

What varies from one Tile to the next is the asset underneath — and the tools and runtime it demands. Tile types cover omics formats like VCF and H5AD, whole-slide pathology imaging, everyday document files, and tabular data both as files and as warehouse tables in Databricks or Snowflake; the current list lives on our product page. We also offer custom Tiles co-built with your team — think internal APIs, legacy databases, and proprietary formats.

Human, pipeline, app, or AI agent — they all call the same tools, through whichever interface they already use, under the same rules.

An interpreter next to your data

A Tile is the interpreter standing next to your data: it speaks the data’s language so your AI doesn’t have to, and the data stays where it lives. Source, Context, Tools, and Runtime are what that interpreter is made of. An agent talks to the interpreter, never to the raw bytes — which is why you don’t have to teach every agent every format. Add the interpreter once, and every agent that shows up already knows how to work with that source.

One surface over every source

Raw sources each speak their own dialect. A genomics variant store, an imaging archive, a Snowflake table, and a Salesforce object have almost nothing in common at the bytes-and-protocol level. Agents, on the other hand, speak one language: they call something and read what comes back. The Tile does the translation. The set of Tiles becomes a registry of callable interfaces over your entire estate — the surface agents build on. That surface is the Enterprise AI Data Substrate: one Tile activates a source, and Tiles together activate all your data — wherever it lives, whatever the format.

The alternative is one integration per source, forever. Point an agent at raw sources, and each new source repeats the same work: a connection to secure and maintain, a runtime that can read the format, and an audit trail that holds across a whole multi-step session. A Tile does that work once, and the same way for every source — and it adds the thing per-source integrations can’t: one place to search across all your sources and pull answers from them. That’s what makes your data Discoverable, Accessible, and Governed.

Universality is the point

The hard part — and the reason this is a primitive and not a feature — is that a Tile over a genome variant file behaves exactly like a Tile over a ledger table. How it’s found, how it’s reached, who’s allowed, what’s recorded: identical. That consistency across radically different data is what makes “all your data, wherever it lives” possible. An agent doesn’t need to know whether it’s reading imaging or invoices; it calls a Tile, and the Tile handles the rest. And because every Tile behaves the same way, an agent can call several at once.

One question, many Tiles

A single Tile answers a question about one source. Enterprise questions rarely stop at one — so an agent has to call several Tiles at once.

Take a question like:

That’s a variant Tile, a single-cell Tile, and a document Tile, each queried in place, in one workflow.

Every call runs as the person asking, so every step is attributable — and no data has to be copied or converted to answer it.

Each Tile you add is immediately available to every agent and every person already working — so the workflows you have don’t just gain one more source, they reach further. That’s what makes the Tile the building block of enterprise AI: whatever gets assembled on top, the same governed unit sits underneath.

No shadow AI, by construction

Because every source is reached through a Tile, every call runs under the caller’s identity and lands in the audit log. Tile.ai doesn’t add an identity plane of its own — access federates through the identity provider you already run, under the roles and policies you’ve already configured, and the source’s own permissions stay the floor: Tile.ai never grants what a source denies. What changes is that access to every system runs through one interface, so there’s one place to audit it. There is no ungoverned side door.

That’s what keeps coverage from costing you control. The usual pattern runs the other way: a team needs one more source, someone stands up a hand-built MCP server with a service account and broad credentials, and it works — right up until nobody can say who read what. Here, a new source means a new Tile type: the same governed unit, one more format. Coverage grows, and the governance model doesn’t fragment.

From files to tables to Tiles

The file has lasted since the mainframe era because it was the right abstraction for people working with documents. The table has lasted nearly as long because it was the right abstraction for applications working with structured data. The agentic era needs its own primitive: one built for systems that reason over any kind of data at machine speed, under governance. Fifty years from now, agents will take some primitive as much for granted as we take the file. We built the Tile to be it.

Stop telling your AI to talk to files and tables.

Let it talk to Tiles.