14 posts tagged with "AI agents"

How do you actually know your agent is production-ready? "It passed my last three tests" is a sample size, not a score. Actually know, with a statistically meaningful number behind it. That's what Pass@1 / Pass^k (from our last post), the reliability benchmark for moving an AI agent to autonomous action, is for.

Agents are trustworthy when they are highly unlikely to make errors while performing lots of tasks. Pass@1 determines the "not likely to make lots of errors" part of the benchmark. Pass^k determines the "reliability while performing lots of tasks" part. Together, these metrics provide a systematic way to establish how reliable an agent actually is at doing meaningful work.

But here is the harsh reality: manually testing an agent to prove it hits a 95% Pass@1 score is a monumental task. If a developer has to manually run 100 permutations of a prompt just to "verify" an agent, you haven't actually automated anything — you've just moved the bottleneck.

In this post, we'll walk you through exactly how to close that gap: turning a loosely defined agent into a hardened, stress-tested one using the Boomi Agent Trust Scorecard, step by step.

Ever worked with someone who "just knows" how the production system behaves — who can tell you a batch silently failed before the error even shows up? That knowledge never makes it into a tutorial. It's what you only get from actually managing primary data in production — knowing that a batch can report success and still merge nothing, that the algorithm you pick for matching last names quietly decides which customers become one record, that a model in draft bends to your will but a published one will fight you every step of the way. It's specific, it's earned slowly, and on most teams, it lives in one or two people's heads.

The newest skill in the Boomi Companion portfolio writes that knowledge down in a form that an agent can use. The boomi-datahub skill lets AI systems like Claude Code design, deploy, and steward your Golden Records against a live Boomi Data Hub, and get it right far more often than a model working from training data alone.

Turns out, the easiest way to build an agent is to just ask for one. You know that gap between "I have an idea for an agent" and "I have a working agent"? The fastest way to close it: describe what you need — what it should do, what it should reach, how it should sound, and watch it get built on your live Boomi Agentstudio account: structured, equipped with tools, published, and tested, without you ever leaving the conversation.

That's the newest skill in the Boomi Companion portfolio. boomi-agentstudio gives AI systems like Claude Code the whole path from idea to working agent: author it, give it tools, package it, deploy it, and talk to the result.

With Agent Garden REST APIs, build, manage, and invoke agents directly from your code and tools. Where Embedkit CDN gives you invocation from outside the Platform, these APIs give you complete control over the full agent lifecycle.

This blog introduces what you can do with these APIs.

Building an AI agent that works in a demo is one thing. Getting it to behave consistently, respond correctly to unexpected inputs, and perform well under production load is a different challenge. The gap between those two states is where most agent development time actually lives.

This blog covers how to test agents effectively, write instructions that work, address performance bottlenecks, configure tools properly, and set up guardrails that protect without blocking.

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.

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.

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.

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.

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.