Agentic AI foundation (AAIF)

Infobip and the agentic AI foundation

This year Infobip became a Gold member of the Agentic AI Foundation (AAIF)(opens in new tab) - a Linux Foundation initiative where companies work together on open standards for agentic AI, starting with the Model Context Protocol (MCP)(opens in new tab). We're the first company from Croatia, and this part of Europe, to join. That's a nice fact, but it's not really the point. The point is that a handful of our engineers now get to sit in the room where decisions about tools we already build with are being made, instead of finding out about them after the fact in a changelog.

What we actually spend time on

AAIF runs a set of technical working groups, each looking at a different slice of the problem: agent reliability, identity and trust between agents, security, commerce, regulatory alignment, and so on. We wouldn't put too much weight on the exact shape of that list - foundations like this reorganize as the field matures, and what's seven groups today may well be five or ten next year.

What matters more is the kind of work happening inside them, and most of it is unglamorous. A lot of the early sessions are spent reading through specifications that already exist elsewhere and figuring out where they overlap or contradict each other, before anyone proposes something new. Some of our engineers have taken on exactly that: cataloguing what's out there, writing down the use cases we run into building our own products, and flagging the gaps that don't have good answers yet - things like identity for a language we care about but a bigger member doesn't, or agent autonomy rules that need to hold up under EU regulation. None of this produces a headline. It's closer to the maintenance work that keeps any standard honest.

Why it's worth our time

Standards move fast right now, and a standard nobody uses isn't worth much either way. Being in these conversations early means we see where the direction is heading before it shows up in the libraries and SDKs we depend on. That's useful in a very ordinary engineering way: picking the wrong technical direction now is exactly how expensive tech debt gets created later, and it's cheaper to notice that from inside the room than to discover it in production.

It also means our own use cases get a chance to shape what's being written, instead of getting bolted on afterward. A good chunk of what we build touches communication - agents that need to reach people over SMS, WhatsApp, or voice, confirm something with a human before acting, or hand a task off to another agent entirely. Those are exactly the kinds of scenarios that are easy to overlook if the people writing a spec have never had to solve them. Bringing them in early, while charters are still being drafted, is a small thing, but it beats the alternative.

There's a quieter benefit too: none of this stays with the handful of people who happen to attend a session. What gets learned there filters back into internal conversations about how we build agent-related products, and outward through things like ShiftMag, our work with regional partners like Infinum, and the startups in our Startup Tribe. We didn't get invited into this because we've already figured it all out - most of the space is still being figured out by everyone at once. We just happen to be one of the smaller companies at the table, which is a decent position to learn from and occasionally to be useful.