The periodic table of enterprise AI

Picture the average enterprise AI landscape today: a chatbot the customer service team loves, a document summarizer legal built six months ago, a risk-scoring model from the data science team, an automation ops wired together with duct tape and good intentions.

None of them talk to each other. Half of them will need to be rebuilt when the underlying model changes. And somewhere, a leadership team is asking why, after millions of dollars in AI investment, it still feels like they’re starting from scratch every time.

The problem isn’t the technology—the models are extraordinary. It’s that most enterprise AI is built without an architecture, opportunistically, one project at a time, optimized for the demo rather than for the decade.

Slalom decided to build the architecture first. And the blueprint came from an unlikely source: a chemistry class.

In 1803, John Dalton proposed that all matter is composed of atoms—discrete, indivisible units that combine to form everything that exists. The insight wasn’t just scientific. It was a design principle: if you get the fundamental unit right, complexity at any scale becomes manageable.

We applied that logic to AI agents.

An atomic AI agent is a self-contained, independently testable AI agent designed to perform one specific task. Each agent has defined inputs, outputs, logic, and validation criteria, allowing it to operate independently or combine with other agents into larger enterprise workflows.

Examples include a fraud-signal detector, contract-clause extractor, churn-risk scorer, or meeting scheduler. Each is an atom: narrow, specific, complete, and indivisible.

That last word matters more than it sounds. An agent that corrects grammar and checks tone isn’t atomic—it’s two agents sharing an apartment. That distinction feels pedantic until you try to test, reuse, or govern a system of hundreds of agents at scale. At enterprise scale, that seemingly small distinction becomes a foundational architectural decision.

Every atom in our catalog is tagged three ways: by industry vertical (healthcare, financial services, retail, telecom), functional domain (customer service, IT ops, finance, sales), and AI agent archetype—the kind of intelligence it expresses.

• Analyzers surface patterns, risks, and insights from data
• Generators create content, code, and structured outputs
• Extractors pull specific signals from unstructured sources
• Operators execute actions in external systems and APIs
• Planners sequence and coordinate multi-step work
• Conversers engage in goal-directed, context-aware dialogue

These tags aren’t cosmetic. They’re the schema that makes atoms discoverable, governable, and combinable across an enterprise. Without the taxonomy, you have a collection. With it, you have a system.

Atoms bond. Molecules work. Organisms transform. The chemistry metaphor becomes practical when atomic AI agents combine into reusable workflows—and those workflows combine into end-to-end systems.

Atoms make responsibility explicit. Each one declares exactly what it does and nothing more. When something fails, you don’t debug a monolith—you identify the atom. Accountability is precise. Fixes are contained. The integrity of the whole depends on the integrity of the parts.

Molecules create business capability. A single atom that scrapes a webpage is a utility. But bond a web scraper to a pricing extractor to a competitive positioning analyzer, and you’ve synthesized an automated market intelligence pipeline that a product team can run every morning. Individual atoms are often unimpressive on their own. The molecule they form is a product.

Organisms reshape how work gets done. When molecules—tested, validated workflow units—compose into end-to-end systems, you’ve crossed a threshold that changes the nature of the work itself. A customer onboarding organism. A regulatory compliance organism. An AI-accelerated software delivery lifecycle where repeatable steps can be handled by specialized agents. These systems move beyond demos to become new operating models, built from interchangeable, reusable parts that can evolve independently as the underlying science advances.

The journey from atom to organism isn’t a metaphor for ambition. It’s a literal deployment roadmap—and it’s exactly the path this program has been walking.

The Gemini Atoms Program, a collaboration between Slalom and Google Cloud, launched with a mandate that was equal parts exciting and clarifying: build 250 production-ready atomic agents, spanning industries and functions, each tagged, validated, and ready for real-world deployment.

Not AI for the sake of AI adoption, but a living library of enterprise intelligence—a periodic table of AI capability that any team could draw from, combine, and deploy.

The early work looked like what it needed to be: deliberate, methodical, and slow by design. The first agents were developed manually, one per week, establishing rigorous naming conventions, directory structures, quality gates, and other standards—the molecular bonds that would hold the system together as it scaled.

But one agent per week is a four-year program. And the team had something more transformative in mind.

As the team confronted the limits of building agents one at a time, a new design question emerged: Could the same agent architecture accelerate its own development?

The result was a pair of AI-powered development skills—guided tools that help developers define and build agents—/shape-atom and /build-atom—that together form a fully conversational agent development workflow.

/shape-atom handles the fuzzy upstream work: a developer describes an idea, and the system runs a structured interview—probing scope, inputs, outputs, edge cases, and taxonomy fit—until the idea crystallizes into a signed specification brief. /build-atom takes that brief and scaffolds a complete, production-ready agent: directory structure, tool definitions, test scenarios, evaluation harness, and a CI pipeline. Everything needed to merge, validate, and ship.

The first fully automated atom went from idea to merged pull request in about two and a half hours. It scored 89 out of 93 on its gate evaluation, which measures whether the agent meets defined quality and outcome criteria. The four misses included one genuine failure—a garbled date input that caused the model to misidentify the meeting organizer—which the framework caught, named precisely, and resolved in minutes.

The result was a shift from roughly one hand-built agent per week to multiple AI-assisted agents per day, at a compute cost of approximately $2–$3 per agent.

That’s not just faster. That’s a different category of speed—and the standards didn’t move to get there. They got encoded. Every naming convention, every gate criterion, every test coverage requirement is embedded in the skill and enforced automatically on every run. The guardrails aren’t a constraint on velocity—they’re the reason velocity is trustworthy.

Shape → scaffold → validate → ship. The DNA of a replicable, scalable build process.

Speed surfaces failure modes that slower processes never encounter. Here’s one that matters for any organization deploying AI at scale.

A scheduling agent was booking meetings correctly—right time, right participants, right details, every time. But the evaluation framework kept marking it as failing. On closer inspection, the test harness was comparing raw argument strings. The model was penalized for collapsing a double space in a subject line, lowercasing a timestamp, or omitting a blank field that the tool ignored anyway. The outcome was identical: The metric said the atom was broken.

Left uncorrected, that creates a slow-moving disaster: developers start writing tests that describe the exact string the model must produce, not the outcome it must achieve. The test suite stops being a quality gate and becomes a brittle replica of the implementation—one that passes confidently and fails silently in production.

The fix was architectural: stop comparing what the model said, and start comparing what the tool did. Run the expected arguments through the actual tool. Run the model’s arguments through the actual tool. If the results match, the atom passes, creating a deterministic comparison focused on the outcome rather than superficial variation.

This approach rescued four test cases that were genuinely correct—and caught one that was genuinely wrong. On a garbled date input, the model had quietly reassigned the meeting organizer into the attendee list, producing a calendar event with no organizer at all. It passed the old test. It would have failed in someone’s calendar.

The principle: evaluate outcomes, not implementations. The model’s job is to achieve a result. The gate’s job is to verify that result was achieved—not to police the path taken to get there. Any quality framework that confuses these two things will eventually produce confidence exactly when it shouldn’t.

As the catalog grew, a more consequential question surfaced: How would these reusable agents translate into outcomes an organization could deploy, measure, and scale? Building 250 agents is an engineering achievement, but scale alone doesn’t create business value. Moving AI agents from experimentation to value creation requires connecting them to real workflows, measurable outcomes, and the problems leaders are accountable for solving. A healthcare leader needs to see where the ROI is. A CFO needs to understand what AI is worth to the business.

A collection of atoms, however well-built, isn’t a strategy. What leaders need is AI agents organized around buisness outcomes—the molecule, not the element.

That’s why we deliberately shaped the program around what clients actually need to move forward: industry-specific solution playbooks built on reusable agents, packaged with working demos, business case frameworks, and real deployment references—so organizations can see the value, justify the investment, and deploy with confidence.

Examples include:

• Healthcare: Atoms for prior authorization processing, clinical documentation, and patient communication, synthesized into an end-to-end administrative workflow.
• Financial services: Atoms for KYC verification, fraud signal detection, and audit trail generation, assembled into a compliance organism.
• Technology: Atoms for code review, incident triage, and documentation generation, composed into an AI-native engineering workflow.
  

Atoms provide reusable intelligence. Molecules turn that intelligence into workflows. Playbooks package those workflows around business outcomes.

This is what enterprise AI at scale looks like: not one powerful model attempting everything, but a governed ecosystem of specialized, interoperable agents organized by taxonomy, validated by rigorous gates, and assembled into solutions that solve real, high-value problems. The infrastructure layer of the AI-native enterprise. Built from the bottom up, one indivisible unit at a time.

What began as an architecture for the Gemini Atoms Program points to a broader blueprint for scaling enterprise AI. By designing agents as specialized, independently testable, reusable units—and building governance into how they are created and combined—the framework addresses some of the hardest challenges organizations face as they move from AI pilots to production at scale.

1. You stop rebuilding. When agents are tagged, documented, versioned, and tested, capability accumulates in a shared system rather than remaining siloed in individual projects. The next team that needs a churn predictor or a contract extractor finds one—they don’t build one.
2. Quality becomes structural, not aspirational. Standards embedded in the build process enforce themselves. The framework doesn’t depend on every developer remembering every rule. It remembers for them.
3. Governance operates at the right level. Each atom is independently auditable. You don’t inspect a monolith—you inspect the unit. That’s the architecture that makes enterprise AI governable as it scales.
4. The business case writes itself. When atoms compose into playbooks, and playbooks map to measurable business outcomes, the ROI conversation changes from trust us to here’s the molecule, here’s the workflow, here’s what it replaces.
5. Model upgrades stop being migrations. Because each atom is self-contained, you can assign the right model to the right job—a lightweight, low-cost model for simple extraction tasks, a more powerful reasoning model for complex analysis. When a better model comes out, you upgrade the atoms that benefit from it and test only those. No workflow-wide overhaul. No regression risk cascading across the system. One atom, one upgrade, one test.
   

The Gemini Atoms catalog now includes hundreds of atomic agents, each designed around one bounded responsibility and organized by industry, functional domain, and archetype. Each is tested against defined quality gates and designed to be reused and combined with others. Those agents form the building blocks for molecules: validated workflow patterns that combine specialized capabilities around a business need. The program also provides the scaffolding to assemble those workflows into larger, deployable AI systems. This progression—from bounded agent to reusable workflow to enterprise system—is what makes the architecture easier to test, govern, adapt, and scale.

Each atom is designed around one bounded responsibility and a consistent validation contract. That discipline is the foundation for trust and scale.

When you have 250 of those, each one validated and reusable and ready to combine, you don’t have a catalog of demos. You have something closer to what Dalton described in 1803: a set of fundamental, reliable units from which anything can be built.

The periodic table of enterprise AI.

The molecules are bonded. The organisms are emerging. And we’re just getting started.