Declarative Data Infrastructure for Multimodal AI
Pixeltable is the only open-source Python framework that lets you define your entire multimodal workflow (from storage to transformation to inference) as computed columns on a table.
It automates the data plumbing, versioning, and incremental updates, letting you focus on logic instead of complex pipelines.
What this means for you:
Incremental computation: Only processes changes, saving time and cost.
Automatic versioning: Full lineage tracking for reproducibility.
Unified system: Handles data, transformations, and AI models in one place.
Focus on your application logic, not the infrastructure.
Fully open-source.
GitHub repo → (don’t forget to star)
A Guide to Building Agent-Ready APIs
Postman’s 2025 State of the API Report is one of the most important documents you can read today as a developer.
Essentially, we are headed into an era where every website must be “Agent-ready”.
Agents will make purchases, not humans.
Agents will find the best options, not humans.
Agents will fill out job applications, not humans.
The same applies to APIs.
89% of devs use AI daily, but shockingly, only 24% design APIs with AI agents in mind.
Addressing this is crucial because while human devs can hustle through poor docs and broken endpoints, most Agents can’t (yet).
They need:
Predictable structures
Machine-readable schemas/metadata
Standardized behavior
The fix starts with machine-readable documentation that stays in sync with your schema.
Here are some ideas from the report:
Provide machine-consumable metadata
APIs need to have machine-consumable metadata because humans and AI process information differently.
For instance, as shown in the snippet below, a human developer can understand plain English docs and fill in the gaps with contextual knowledge, like user ID is a UUID.
But AI would not have that implicit context, and so the AI-ready version of the API should provide explicit semantic meaning.
You don’t have to prepare this AI-ready metadata manually. Spec Hub is built for such purposes, and it turns API specs into structured metadata.
Enrich error semantics
The standard way to define errors should dramatically change as well.
By looking at the standard error message, a developer can think of multiple things to resolve this with using implicit knowledge or past experience. But an AI system has none of that intuition:
That’s why, as shown above, the AI-ready error messages should not only explain exactly what went wrong but also provide explicit steps to fix the issue.
For instance, in the above error message, the “expected” and “received” fields are really valuable for AI systems because they essentially tell the AI, “Here’s how you can solve this problem.”
Again, you don’t have to prepare this manually for Agents.
We often use Postman Insights to get visibility into how your API behaves in real-world use.
This helps catch inconsistent responses, unclear errors, or performance issues, all of which can confuse AI agents.
APIs should be discoverable
AI systems can only integrate APIs that they can find.
Human devs often find APIs through explicit search, internal wikis, Slack, friends, social channels, etc.
AI agents can’t do that. If an API isn’t published with clear metadata, discoverable endpoints, and open access, it simply does not exist for Agents.
The Postman API Network hosts 100k+ publicly available APIs that are purpose-built for visibility, discoverability, and machine-readiness.
APIs should be well-documented
If a human dev faces issues with docs, they can search the web, open Stack Overflow, and more.
But Agents can’t use what they don’t even understand.
Thus, APIs must be well-documented so that Agents can easily learn everything about them and establish an entry point.
Otherwise, they will have no reliable way to discover what endpoints exist, what parameters to pass, what data to expect in return, or how to recover from an error.
Yet again, this step can be automated as well.
Postman’s Agent Mode automatically generates detailed, contextual documentation for APIs based on your request/response examples and usage patterns.
This video showcases its usage to generate a machine-readable documentation:
This makes it simple to turn any collections into interactive docs that are always up-to-date for Agents.
On a side note, Agent Mode can do a lot more. This is Postman’s AI-powered platform to explore, debug, and build APIs using natural language.
There’s a lot more in the AI-ready APIs Playbook that we haven’t covered yet, but the core takeaway stays the same: Agents using APIs should NOT be guessing.
Document everything in a way that both humans and machines can understand.
Every time an agent has to infer how your API works, you introduce friction, inconsistency, and potential errors.
Postman makes it trivial to design → document → publish → monitor APIs that both humans and agents can use reliably.
Thanks to Postman for preparing this report and partnering with us today!
👉 Over to you: Are you building AI-ready APIs?=
Thanks for reading!