DocumentationLogin
Enterspeed logo
Enterspeed Blog
Product

Agents are your newest consumer: serving Enterspeed data to AI agents

Jesper Weber
Jesper Weber
Developer Experience Engineer at Enterspeed
Thumbnail for blog post: Agents are your newest consumer: serving Enterspeed data to AI agents

For a long time, the list of things consuming your data was fairly predictable: a website, maybe a mobile app, maybe a search index. Each one knew exactly what it needed. The website asks for the view at /products/cordless-drill, renders it and moves on.

Agents don't always work like that.

An agent might get a question like "which of our cordless drills cost under 1,500 kr.?" and have to work out where the answer is, what the data looks like and how to fetch it. Another agent might run the same lookup a thousand times a day as part of a fixed workflow. Both are agents, but they need very different things from your data layer.

How agents usually get data today

Most agents today get their data in one of three ways, and each has a catch.

Reading the website. The agent scrapes or browses your public pages. It works, but the agent sees whatever was designed for humans: layout, navigation, marketing copy, prices formatted as text. Structured facts have to be reconstructed from HTML. Using structured data on your website like microdata or JSON-LD can help, but the agent still needs to parse the full HTML.

Chunked documents in a vector store. Content is exported, split into chunks and embedded for retrieval. Good for questions about documents, less good for questions with exact answers like stock levels, prices or "all products in this category".

Direct connections to each source system. The agent gets its own integration with the PIM, the ERP and the CMS. That's point-to-point integration again, with every source system exposed to a consumer that's harder to predict than a website.

What agents actually need

Looking at how agents work, a few requirements stand out.

Discoverability. An agent exploring your data needs to find out what exists and what shape it has before it can ask for anything.

Structure. Exact questions need structured data with typed fields, not prose. "Under 1,500 kr" is a filter, not a semantic search.

Fresh data. If the stock level changed ten minutes ago, the agent should know.

Scoped, read-only access. An agent should see the data it's meant to see and nothing else.

Answers that fit. Agents work within a context window. A response that returns 50,000 products in one go isn't helpful to anyone.

Enterspeed: same data, one more consumer

If you already use Enterspeed, agents don't need their own data pipeline. They're just another consumer of the same data, next to the website and the mobile app.

Diagram: five source systems (CMS, PIM, ERP, CRM, and other systems) feed into Enterspeed, which serves the same data to three applications: agents, a website, and a mobile app.

One data layer, three consumers. Agents read the same data as your website and mobile app.

Your source systems push data into Enterspeed once. Schemas shape it into views served through the Delivery API, and into index items that can be queried through the Query API. Agents use the same data, kept up to date by the same ingest, without a separate export.

There are two ways for an agent to reach it: the Query MCP server and the REST APIs. Which one fits depends on whether the agent has to explore or already knows what it needs.

Option 1: the Query MCP, for agents that explore

The Enterspeed Query MCP server turns the Query API into Model Context Protocol tools that AI clients such as Claude, Cursor, Copilot or your own agents can discover and call. Enterspeed hosts the server, so there's nothing for you to run.

It's built around the discoverability problem. The tool list is assembled for each connection, in layers:

  • Static tools for everyone, such as get_indices to list the indexes the agent can see, describe_index to get an index's fields and which of them are searchable or sortable, and get_operators to see which filter operators are available.

  • A tool per index, generated from that index's own fields. If you have a products index, the agent gets a typed query_products tool and doesn't have to build a generic filter by hand.

  • A tool per auto-indexed source entity type, so agents can also explore raw source data where that's enabled. Typically small pieces of data that come in hundreds of thousands or millions, like B2B prices or stock counts, that change regularly and need to stay up to date.

  • A unified query tool for querying several indexes in one call.

For the drill question above, a typical flow is: list the indexes, describe the products index to see that it has category, priceDkk and attributeCordless fields, then call query_products with a category filter and a price filter. The agent works it out from the tools themselves, and the answer is based on actual data.

The MCP is the right choice when the questions aren't known in advance: an assistant for your sales team, an internal analyst agent, or someone exploring data in Claude or Copilot.

Option 2: the REST APIs, for agents that already know

Not every agent needs to explore. If you're building an agent into your own product, or running a fixed workflow in something like Power Automate, you usually know exactly which data it needs. Then it's often better to call the APIs directly.

The Query API lets you send a known query to an index:

1POST https://query.enterspeed.com/v1/products
2X-Api-Key: <environment client key>
3Content-Type: application/json
4
5{
6  "filters": {
7    "and": [
8      { "field": "category", "operator": "equals", "value": "Drills" },
9      { "field": "priceDkk", "operator": "lessThan", "value": 1500 },
10      { "field": "attributeCordless", "operator": "equals", "value": true }
11    ]
12  },
13  "sort": [{ "field": "priceDkk", "order": "asc" }],
14  "pagination": { "page": 0, "pageSize": 20 }
15}

The Delivery API is useful when the agent already has a URL and knows exactly which product or any other piece of content it needs, for example from a search result or a link a user pasted. Instead of scraping the HTML, it can fetch the structured view behind the page:

1GET https://delivery.enterspeed.com/v2?url=https://www.example.com/products/cordless-drill
2X-Api-Key: <environment client key>

Compared to the MCP, direct calls use fewer tokens, are faster, give the same result every time and are easier to test. The trade-off is that you do the discovery work when you build the agent, rather than letting the agent do it at runtime.

A simple rule of thumb: use the MCP when the question is open, and REST when the question is known. If your setup needs to answer both types of questions, you use both as many real setups do.

It's not either/or. The Query MCP is a thin layer on top of the Query API. Behind the scenes, it forwards each tool call to the Query API, which also handles authorisation. Whichever option you choose, you're working with the same indexes and the same data and that's why they work well together.

Designing data for agents

Agents read your field names and descriptions to decide what to do, so the shape of an index matters even more than it does for a frontend.

Use descriptive field names. priceDkk tells an agent more than p1. A developer can look things up; an agent works with what it's given.

Keep it flat and structured. Return values, not HTML. A stock level as a number and a price as a number with the currency in the field name are easier to filter on than formatted text.

Include the canonical URL. Put the page URL on each index item. Then the agent can link the user to the real page and show where its answer came from, which makes a big difference to trust.

Use text fields for fuzzy search. String fields stored with the text type are analysed, which makes fuzzy search possible through the Query API's search property. That helps when a user's wording doesn't match your data exactly.

Consider a dedicated index. You don't have to reuse the index built for your website's search. An index designed for agents is one more schema, not one more integration.

Good answers need good data. An agent can only answer from what's in the index. If product descriptions are thin or missing, the answers will be too. That's where AI enrichment with Speedtrain can help, as described in our content enricher post.

Access, safety and limits

Everything is a read. Every Query MCP tool is a read, and the Query and Delivery APIs only return data. Configuring a tenant is a separate server, the Management MCP, with its own sign-in.

Access is scoped. People connect to the Query MCP by signing in with their Enterspeed account and selecting a tenant and environment. Agents that run unattended, and agents calling the REST APIs, use a scoped environment client key, which can be restricted to specific indexes. All authorisation happens in the Query API, so the MCP server can't return more than the key allows. Keep keys in a secrets store or environment variables, and never in an agent's prompt or in client-side code.

Answers are sized for agents. On a signed-in MCP session, item tools keep answers to a budget a client can read in full and return a cursor to continue. Items are never cut in half. When calling REST, use pagination and small page sizes for the same reason.

Requests are rate-limited. The Query MCP allows 120 requests per minute per key or signed-in person, and well-behaved MCP clients back off and retry. This aligns with usage mentioned earlier, that the Query MCP is for exploration and the Delivery and Query APIs are for known questions that might be called many times.

Returned content is data, not instructions. If an index contains text written by users, such as reviews or form submissions, an agent should treat it as content to answer from, never as commands to follow. Design your agent prompts with that in mind.

Things to plan for

Access is per key, not per end customer. Query MCP and API access is scoped to an environment and its indexes, not to the person the agent is talking to. If an agent serves end customers with customer-specific data, such as B2B prices or order history, you need a layer in between that knows who the user is and enforces what they're allowed to see. Don't give a customer-facing agent a key that can read every customer's data.

Enterspeed is for knowing, not doing. Enterspeed gives agents read access to your data. When an agent needs to act, such as placing an order or updating a customer record, that action belongs in the system that owns the data, through its own API and its own permissions.

Agents are less predictable than frontends. An exploring agent might query in ways you didn't expect, so watch how your indexes are used and adjust fields and descriptions accordingly. If an agent gives a poor answer, the cause is often a vague field name or a missing field, not the model.

Freshness has a short delay. Index items are updated when Enterspeed processes the source data. That's fast, but for truly real-time data, such as stock at checkout, an agent's answer should be confirmed by the system that owns it.

Summary

Agents are becoming a real consumer of business data, next to websites and apps. Some explore, some follow fixed flows, and all of them need structured, fresh and scoped data.

With Enterspeed, agents don't need a separate pipeline. Agents that explore can use the hosted Query MCP server, which describes your indexes as typed tools. Agents that already know what they need can call the Query and Delivery APIs directly. Either way, they read the same data your other applications use.

One data layer, one more consumer.

Want to try it? Read the Query MCP overview, the guide to connecting an agent, and the REST API reference in our docs.

Jesper Weber
Jesper Weber
Developer Experience Engineer at Enterspeed

Loves building software that makes an impact on businesses. Untalented but happy ice hockey player (the beers just taste better in a locker room after a game...)

Ready to try out Enterspeed? 🚀

Start connecting & combining your services today

Solutions

Product OnboardingPublish-ready product dataGoverned AI contentReplatform and migration
Enterspeed logo

© 2020 - 2026 Enterspeed A/S. All rights reserved.

Made with ❤️ and ☕ in Denmark.