Ahead of the QAD conference in Bangkok, we were tasked with building a real-world demo showcasing the capabilities of Boomi Companion for manufacturing customers using QAD ERP. The challenge was straightforward, but the underlying problem it addressed is one most manufacturers deal with every day.

Many customers in Indonesia still don't use EDI (Electronic Data Interchange) for order processing. Orders often arrive via channels such as WhatsApp, SMS, and email, creating manual overhead and delays that slow down every transaction.

In less than a few hours, we were able to build a working prototype where:

• A customer sends a sales order request over WhatsApp.
• Boomi processes the request.
• A sales order gets created directly in QAD via QDoc APIs.
• The customer queries order status directly from WhatsApp.

Big news: llms.txt support has officially landed on both Boomi Help Docs and the Boomi Developer Docs. If you've ever wanted to point an AI tool at our documentation and get instant, accurate results without the "noise," this is for you.

Check them out here:

• help.boomi.com/llms.txt
• developer.boomi.com/llms.txt

Whether you're building a RAG pipeline, coding with an AI assistant, or querying Boomi docs through an AI search tool, these files are your shortcut to answers grounded in current, accurate documentation. We've also built a smart tiered structure into both sites, so real-time agents stay fast, and bulk pipelines get everything they need.

Creating AI agent skills containing detailed knowledge of how to interact with remote systems on a user's behalf is a new area of product development for most companies. Much of the tooling that exists in the software development world for ensuring code quality doesn't fully extend or apply to developing AI agent skills, which are primarily natural language text files.

The approachability of this format may entice users to ask an AI agent to naively create skills based on questionable/incomplete documentation, with very few guardrails to spot inefficient, insecure, or even blatantly incorrect instructions. The Boomi Companion team is attempting to elevate skill development by incorporating hard-won lessons from traditional software development, including not only being careful and considered in our approach to security, but also being transparent about the decisions we've made and how we've implemented our design choices. Enabling users and their agents with the equivalent of years of experience using the Boomi Enterprise Platform is extremely powerful, but convenience can (and usually does) come with security caveats and tradeoffs. This blog will demonstrate how the Boomi Companion development team has been considering those implications, the mitigations we've implemented, and what might still be desirable for "hardening" an agent-based build system.

Your integration Platform is only as powerful as what your team can build with it. That gap between Platform capability and your team's capability has always been the real challenge in enterprise integration. Claude Code Skills are designed to close it.

By embedding AI-powered development capabilities directly into the Boomi Platform through Claude Code Skills, Boomi enables you to build, test, and deploy integrations using natural language, regardless of your technical background. This blog explores what that means in practice, how the architecture works, and why it represents a fundamental shift in how you realize value from Boomi.

Building EDI (Electronic Data Interchange) integrations can be slow, complex, and frustrating. Weeks of mapping, testing, and coordinating across multiple systems can quickly stretch into months.

That is exactly what Boomi Companion solves. It lets you describe your integration requirements in plain English and have them built, tested, and deployed in hours. This is not just a concept. It is already a production reality for thousands of businesses, transforming how they connect systems and automate workflows.

If you have ever worked with EDI, you already know the drill. Weeks to onboard a single trading partner. Testing cycles that drag on longer than they should. Maps that demand specialized expertise just to get started. Traditional EDI has been slow, complex, and resource-intensive for decades.

That's where Boomi's AI assistant, Boomi Companion, comes in. In this blog, you will learn how Companion tackles each of these bottlenecks head-on.

Boomi Companion is our portfolio of open source Agent Skills and plugins — designed to give any AI agent the expertise to do real Boomi work.

Agent Skills are an open standard, which means Boomi Companion slots naturally into coding agents like Claude Code, OpenAI Codex, and Google Antigravity, as well as into chat experiences like Claude Cowork. Wherever your team's agents are doing real work, Boomi Companion can come along.

This first release focuses on hands-on building, with skills for implementing integration processes, EDI (Electronic Data Interchange), and Event Streams. It can also pull from existing recipes and templates on marketplace.boomi.com. The rest of this blog walks through what's included, why we built it the way we did, and what it looks like in practice.

In late March 2026, I (Jeremy Eastburn, Principal Developer Advocate) teamed up with Michael Bachman (Boomi's Head of Research, affectionately known as "Bachman") for a major undertaking: a 6-week, 50,000-mile world tour. We crossed 3 continents, traveling from the US to Sydney to Bangkok, to speak with dozens of customers, partners, and government agencies.

The primary mission of this fast-paced tour was to introduce our new open-source developer offering, Boomi Companion: a suite of Agent Skills designed to help anyone activate their data faster and accelerate time to value with the Boomi Platform.

Not one person we met with had ever seen Boomi Companion, and some had never even heard of Boomi. But across 30+ conversations, the same reactions kept surfacing in different rooms: "gamechanger," "extraordinary," "what we've all been dreaming about," "it lowers the barrier to entry."

Primary data is not static. It is constantly evolving as systems update records, contributors make changes, and models get revised. What starts as a simple dataset can quickly turn into a complex web of pipelines, models, and dependencies.

Managing this evolution requires visibility, not just into the data itself, but into how it changes, who modifies it, and how it flows across systems.

This is where the Boomi Data Hub Platform API comes into play.

Data Integration makes it easy to build Data Flows in the UI. You can drag, drop, and connect things faster. But relying solely on the UI can run into problems, especially when you need to move a pipeline between environments without breaking anything and ensuring repeatable deployments, reviews, and traceability. Suddenly, that “clicky” workflow starts showing cracks.

This is where treating your integrations like code comes in! By leveraging REST APIs and treating your configuration as an artifact, you can automatically version, test, and deploy, giving your Boomi projects the same DevOps treatment your apps already enjoy.

If you have worked with Boomi Data Hub you already know how critical clean, governed primary data is for downstream systems. But when that data needs to flow into analytics platforms, operational applications, or machine learning pipelines, relying solely on the UI quickly becomes a bottleneck.

That’s where the Boomi Data Hub Repository API comes in!

Every championship game coach knows the secret: you need more than talent to win it all. You need a game plan, a playbook, and the right roster. The same idea applies to AI agents.

Building great AI agents is a lot like building a championship team. This framework represents the Tasks-Skills-Tools model, which breaks things down into three simple layers: what the team is trying to accomplish (Tasks, or the Game plan), how they approach the work (Skills, or the Playbook), and what they can interact with (Tools, or the Roster). Just as elite sports organizations don’t conflate their season goals with their play designs or their roster, successful championship team architectures keep these layers clearly separated—making teams easier to manage, more flexible to evolve, and better performers overall.

The AI world is moving fast, and everyone’s trying to bring generative AI into their apps, from auto-generating content to building smarter assistants. But let’s be real, integrating it into real systems can be a headache. Industry analysis shows that over 65% of AI projects hit delays, often because teams get stuck managing APIs, auth flows, and security instead of building the features they actually care about.

That’s where Boomi’s Amazon Bedrock connector comes in! It bridges the Boomi Platform and Amazon Bedrock’s powerful generative AI capabilities, so you no longer have to manage REST API calls, request signatures, or authentication flows.

Every connector developer has bumped into the limitations of the default Custom Properties table at some point. Fixed labels, generic fields, and features like encryption don’t always reflect what your users actually need. The good news? The latest SDK (2.28.3) enhancements finally give you the freedom to shape this table the way you want, and it’s much simpler than you might expect.

Here’s how you can transform the default table into something that truly fits your connector and why these changes matter.

At Boomi, we've embedded Anthropic's Claude across our entire technology stack - from how we build our platform to how our customers build with it. This is that story.

AI has crossed the enterprise threshold. The shift happened beneath the hype cycle: agents that maintain context, orchestrate workflows, and write to real business systems. Production deployments are replacing proof-of-concepts. This shift demands infrastructure and reliability.

Have you ever built a connector that sends data into a process and then just waits, wondering what happens next? You’re not alone, we’ve all been there. The good news is that with Connector SDK 2.28.3, your connectors can finally stop guessing and start learning!

Earlier SDKs let connectors send data and maybe get a status, but not the actual output. The new document retrieval feature in SDK 2.28.3 changes that, letting listener connectors not just send data but also receive the documents and properties a process generates. Now your connectors can react to real outcomes, adapt intelligently, and deliver what developers rely on.

Connectors are the lifeblood of Boomi Integration powering data movement, synchronization, and real-time events across systems. The Boomi Connector SDK gives you the flexibility to create custom connectors tailored to your specific integration needs. Combined with the Cursor Integrated Development Environment you can create a high-performance workspace to accelerate connector development.

This blog walks you through preparing your workspace, integrating documentation, applying coding rules, and automating setup so you can start building robust connectors quickly and consistently.

Boomi’s September 2025 release makes it easier than ever to manage runtime clouds. Instead of relying only on the Boomi UI, you can now use new and enhanced APIs to create a cloud, manage its attachments, and adjust quotas directly through scripts or automation.

As developers, we've all been there - staring at a failing test suite, wondering why our mocks aren't working as expected. Testing can be particularly challenging when building connectors that integrate with external systems. You need to simulate responses from systems you don't control, mock complex behaviors, and ensure your connector handles all edge cases correctly. In this blog post, we'll explore how to refactor your connector code for enhanced testability using standard Mockito, completely bypassing the common drawbacks of PowerMock.

When building connectors on the Boomi Enterprise Platform, the connector-descriptor.xml plays a key role; it defines how the platform dynamically builds the user interface for creating connections and operations. With recent updates to the Connector SDK and platform, developers now have the flexibility to design custom sections within the connection configuration. This means you can group related fields into separate, clearly labeled tabs, each with its own summary—making the UI cleaner and easier to navigate.

Boomi's March 2025 release introduces the Publisher Integration Pack APIs, a go-to for solution builders. These APIs revolutionize how you manage Integration Packs, enabling automation of key tasks like publication, tracking, and account group management. They reduce manual overhead, streamline operations, and enable teams to focus on innovation rather than administrative complexity.

Managing Boomi's document cache, especially with parallel processing, can be challenging. Boomi's document cache allows storing and retrieving documents during process execution, useful for data correlation and lookups. However, direct integration of caching with parallel processing can lead to conflicts, particularly in multi-node environments. Subprocesses and concurrent caching comes handy to address these challenges.

Boomi’s November 2024 release introduced Branch and Merge functionality into the Boomi Platform. While the platform does have a user interface to create branches, package and deploy components on branches, and eventually merge branches, a less talked about but necessary functionality is the ability to automate these processes via API calls to the Boomi Enterprise Platform API.

Connectors are the main components in Boomi Integration. If you use the Integration product and have built integration processes, you’ve used connectors to some extent. Connectors give your integrations life. They can pull data from cloud services, push data to local disks or repositories, or even listen to real-time events. This provides you with a set of tools, libraries and resources to build connectors to suit your needs.

As an Integration Developer, you aim to craft efficient integrations that deliver rapid results and optimal performance. Optimizing the connector configuration is a crucial step that can yield significant benefits. While this might seem like a small tweak, it can have a massive impact on your system's performance. Whether it's faster execution, reduced resource usage, or smoother integrations, the right optimizations can transform bottlenecks into seamless workflows. When every second counts, an efficient connector can make all the difference for large-scale operations.

What’s the first thing you notice when you explore a new API? For developers, it’s often the documentation—and that first impression can make or break the development experience. Clear, intuitive API documentation can mean faster onboarding, fewer integration hiccups, and smoother workflows. That’s why we’ve reimagined Boomi’s API documentation to help you build smarter, faster, and better.

Thinking about building a Boomi connector? One crucial element is how your connector handles data, specifically how it accepts and processes that data. As a connector developer, you're creating a bridge that needs to handle complex configurations while remaining user-friendly.

Boomi offers various property types, each serving a specific purpose. Choosing the right one is essential to ensure your connector is smooth, efficient, and intuitive.