The Agentic Automation Engine:
A New Era of Automation
© Moveworks, Inc
moveworks.com
Executive Summary
The Productivity Plateau: Businesses have invested heavily in SaaS applications,
resulting in a sprawl of interfaces that confuse employees and stall productivity gains.
Each additional piece of software aims to automate more, but contributes less & less to
productivity.
The Rise of Agentic AI: AI agents represent a new paradigm in automation. Unlike
traditional SaaS applications, AI agents use large language models (LLMs) to perform
tasks based on user descriptions, thereby eliminating the need for users to navigate
complex interfaces. This shift promises to break through the productivity plateau by
making business processes more efficient.
Today’s Agentic AI Limitations: We have yet to see AI agents break through the
productivity plateau. This is because traditional automation platforms were not built for
AI agents. They lack the critical capabilities required to overcome challenges with tool
selection, input accuracy, and action execution. Developers are forced to write excessive,
unmaintainable, and unscalable code to make traditional APIs fit into AI agents’ needs,
resulting in inferior outcomes.
Agentic Automation Engine: Moveworks has designed the Agentic Automation Engine
to bridge the gap between AI agents and business systems. This engine is the core of
Creator Studio, enabling developers to build powerful AI agents with significantly less
code. The engine comprises four core pillars:
1. Manifest Generator: Helps AI agents select the correct automation by analyzing
and validating plugins.
2. Slot Resolvers: Converts natural language inputs into system IDs, facilitating
accurate entity resolution.
3. Policy Validators: Ensures AI agents comply with business rules reliably.
4. Action Orchestrator: Connects AI agents with integration code, handling actions
and responses to reduce the need for extensive coding.
The Agentic Automation Engine allows developers to build AI agents faster and more
efficiently, reducing code sprawl and licensing fees. It also simplifies deployment practices
and enhances the reliability of AI agents that are ready for the enterprise.
© Moveworks, Inc
moveworks.com
The productivity plateau
Since the dawn of computing, businesses embraced
technology to improve the efficiency of their
operations & the productivity of their employees.
With the first boom of personal computing & cloud
computing, enterprises heavily invested in SaaS
applications to serve business needs.
1. Process Discovery - How do employees learn
where to start these processes (Is there a form? A
custom internal app? An email alias?)
2. Task Awareness - How do employees keep track
of pending tasks assigned to them? (Is there a task
tracker? A notification portal? Do they just need to
monitor their email?)
3. Task Complexity - How do employees gather the
Today, the typical enterprise has 1000+ applications,
information needed to complete their tasks? (Do
each with its own user interface. When combined
they need to pull data from a few different systems?
with the myriad internal portals & intranets, the
Are there playbooks or guided flows?)
resulting sprawl of application interfaces results
in confusion & low utilizations by employees. As a
result, productivity gains from digital transformation
investments stalled, and economists await a second
boom to revitalize technology-driven productivity.
This plateau is Econ 101: the law of diminishing
marginal utility. That is to say, every incremental
4. Task Duration - How do employees quickly
complete their tasks & responsibilities? (Is there a
tedious set of actions employees have to do?)
SaaS tools slow down work. They deepen
inefficiency. And businesses are forced to employ
experts in the back office to accelerate processes.
piece of software contributes increasingly less to
productivity. Employees find themselves juggling
dozens of applications, portals, & processes.
The rise of Agentic AI
In this regard, AI agents present a new automation
paradigm. Unlike traditional SaaS applications which
An AI agent understands the goal, develops a plan,
and makes relevant tool calls (aka function calls) to
accomplish the user’s task.
expect users to discover and navigate interfaces,
For businesses, there is a new opportunity to
AI agents use large language models (LLMs) to
make AI agents a part of their business processes.
perform automations for users. A user simply
If successful, AI agents will help employees
describes the task they want to accomplish.
breakthrough their productivity plateau and make
businesses significantly more efficient in the
following ways.
© Moveworks, Inc
moveworks.com
Traditional Applications
Agentic Applications
Business Outcomes
Discovery
Developers build portals &
hope employees find intake
forms
AI agents find the right
automation based on the
user’s need
Downsize support staff
required to navigate
employees to resources
Awareness
Employees have to go
to sift through emails &
portals to find pending
tasks
AI agents aggregate a
single view of all tasks
Fewer tasks are dropped or
ignored
Complexity
Developers build a user
interface for every type of
task
AI agents can dynamically
generate the perfect
interface for each task
Higher quality, more
informed decisions are
made
Duration
Developers pre-build &
maintain static workflows
AI agents combine smaller
automations to fit user
needs on-the-fly
Less developer time spent
on editing workflows
Agentic AI needs a new class
of tools
An AI agent needs to be able to Reason, Plan,
and Act.
The world’s leading LLMs like OpenAI’s o1,
Anthropic’s Claude 3.5, Google’s Gemini Pro 1.5 are
increasingly more powerful (larger context windows,
better reasoning, more modalities). This enables
reasoning & planning to scale, but there’s more to
building agents – namely, acting.
Developers assumed that the tool calling capabilities
of LLMs could be used to act with the same APIs
that carry out actions in business systems today.
The reality is that existing APIs & integration
platforms were never designed for use by LLMbased AI agents.
© Moveworks, Inc
moveworks.com
Scale with
LLMs &
Reasoning
Abilities
Plan
multiple steps to solve
AI
agent
Reason
about what they observe
Act
using tool calling
Left behind
1. Inaccurate tool selection
2. Malformed inputs
3. Inadequate interpretation
Traditional automation platforms, like iPaaS and
update existing tasks, reassign tasks, etc.). To build
other middleware, are designed to connect APIs
such an agent, you can imagine that we need to
(which are precise & deterministic) to other APIs.
expose a Reassign Task API, which needs (1) a task
But AI agents connect human language (which is
ID and (2) a user ID to assign it to.
imprecise and ambiguous) to APIs.
But human language is messy – we don’t speak
Let’s take a simple example: Say I want an agent
using IDs. There are dozens of ways that users will
that can help me manage tasks (create new tasks,
specify these inputs:
© Moveworks, Inc
moveworks.com
Limitations like these are why traditional automation
platforms were not built to be used by AI agents.
They lack critical capabilities required to overcome
challenges with inaccurate tool selection, malformed
inputs, & incoherent responses.
Life was simpler for developers in traditional
applications. Developers built web & mobile
interfaces, which used dropdowns and other
components to structure user input. That structured
user input flowed seamlessly between application
layers.
But without the right set of primitives, developers
are forced to make traditional APIs’ round pegs fit
into AI agents’ square holes. As a result, developers
need to write an inordinate amount of excess,
unmaintainable, unscalable code (tech debt) just to
produce the inferior results.
That whitespace between System APIs and Agentic
full potential while they are limited by traditional
AI systems represent the “not quite ready” reality of
automation platforms.
developing AI agents today. This is where the Demo
Devils live.
When it comes time to deploy an AI agent to
hundreds or thousands of employees, “It worked in
my sandbox” isn’t a valid answer when things go
wrong. The investments that businesses are making
in AI agents never see the light of day – they remain
trapped as science projects & demos because they
lack the robustness & maturity to be confidently
deployed across the business.
The whitespace is the reason why AI agents have
yet to proliferate. AI agents will not reach their
© Moveworks, Inc
Unleash AI Agents with Agentic
Automation
To empower developers to break through the
limitations of traditional automation platforms,
Moveworks has designed a new Agentic Automation
Engine.
The Agentic Automation Engine is designed from its
core to build automations that can bridge language
from AI agents and structured data from business
systems. This Agentic Automation Engine is the new
heart of Creator Studio, where developers build AI
agents on the Moveworks platform.
moveworks.com
With this new engine…
1. Developers can build powerful agents that
can handle more complex tasks than AI agents
powered by a traditional automation engine.
2. Developers will be able to build AI agents faster,
with 1/10th the code compared to traditional
approaches.
3. Best of all, developers can build in one connected
platform, eliminating code sprawl, reducing licensing
fees, & simplifying deployment practices. No need to
pay for a separate automation tool.
Using the Agentic Automation Engine, developers
will build plugins which the Moveworks Copilot
uses. Moveworks Plugins are packed with key
capabilities that enable developers to bring AI
agents to life.
Inside our Agentic Automation
Engine
Developers take advantage of these core capabilities
in order to build Moveworks Plugins, which are
automations that are designed for AI agents.
There are 4 core pillars of our Agentic Automation
Engine:
Manifest Generator
1. Manifest Generator - Helps an AI agent select the
If you’re trying to build an AI agent that can connect
correct automation
to every business system, it needs to be able to
2. Slot Resolvers - Helps an AI agent convert natural
understand a user’s request and decide what plugin
language to system IDs
to select. However, without access to the underlying
3. Policy Validators - Helps an AI agent comply with
information within plugins, AI agents are incapable
deterministic business rules
of discerning the right plugin to pick.
4. Action Orchestrator - Helps an AI agent interpret
responses & errors when taking action
© Moveworks, Inc
moveworks.com
Let’s take a simple example. Imagine I have two
As a consequence, developers need to become
plugins:
prompt engineering experts to come up with the
1. Update a PR - Built by a DevOps engineer to close
Github Pull Requests.
2. Update a PR - Built by Procurement IT to amend
an Ariba Purchase Requisition.
With traditional automation tools, all an AI agent
knows is there are two plugins with the same title
and similar inputs (an ID to update and some values
to set like status, assignee, etc.). AI agents get
confused and don’t know which plugin to pick.
© Moveworks, Inc
“perfect” LLM-facing instructions. This may seem
tractable when considering just these two examples,
but imagine when you have thousands of plugins in
one AI agent – you’ll spend more time beating your
AI agent into behaving correctly than expanding it to
support more types of tasks.
AI agents were supposed to eliminate the pains tied
to process discovery, but instead, other solutions
have just converted the “find the right portal”
problem into a “find the right agent” problem.
moveworks.com
AI agents will never be delivered through creative
should be able to execute. Our Manifest Generator
prompt engineering or isolated agents. Moveworks
analyzes & validates its understanding of plugins
Manifest Generator handles this problem differently.
when they’re configured. It then surveys the 1000s
Let’s say your business wants an AI agent for a
domain (e.g. HR), a process (e.g. Onboarding), a
system (e.g. Workday), or a persona (e.g. Sales
Reps). In Moveworks, you build plugins, which
represent the different automations that an agent
of plugins you’ve built, and dynamically produces
a “manifest” (or list) of plugins to present to the
Moveworks Agentic Reasoning Engine. This
manifest of plugins serves as an agent for any
domain, process, system, or persona.
When plugins are configured, the Manifest Generator
during their orientation, the Manifest Generator asks
analyzes them and interprets all the slots, policies,
the developer to clarify when the plugin should be
& actions. Much like a new employee will ask their
used.
onboarding buddy clarifying questions to learn
© Moveworks, Inc
moveworks.com
The developer never has to come up with creative
to augment the Agentic Reasoning Engine’s
utterances or creative descriptions, the Manifest
intelligence. Let’s take the following example: Say I’m
Generator picks the best ones by comparing the
hosting a customer at our company HQ and I need a
plugin & its contents to the other 1000s of plugins
spot for them.
configured in your environment.
The Manifest Generator first filters plugins to the
When it’s time to use the plugin in the Moveworks
best possible subset of plugins that could help the
Copilot, our Manifest Generator continues
user.
In this case, “Book a facility” or “Book a spot” could
problem, we rewrite the plugin descriptions to make
both be relevant plugins based on what the user
them more semantically unique. Now, it’s clear that
described. Presenting them directly to the user
one will help Paul reserve a room for the customer
would be problematic, as they wouldn’t know
meeting, and the other would help him reserve a
which plugin is the right one for them. To solve this
parking spot for his visit to New York City.
© Moveworks, Inc
moveworks.com
Finally, our Agentic Reasoning Engine steps in, to
possible. From knowledge graphs to enterprise
clarify Paul’s intent and ensure the right plugin is
reasoning eval datasets to model distillation &
selected, with human-like intelligence.
fine-tuning techniques, you can be confident that the
Under the hood, the Moveworks Manifest Generator
has a ton of critical innovations that make this
Moveworks Manifest Generator will give you nines of
reliability when it comes to selecting the right plugin.
Slot Resolvers
When you’re building an AI agent for all systems,
Your users want to manipulate these business
you need to be able to actually integrate with those
objects, but something needs to translate between
systems. Unfortunately humans speak in natural
natural language (“Project Orion”) and system
language: “Please add Jim to Project Orion”
language (“67428930”). In the era of SaaS, this
meant developers needed to configure “display
And your business systems speak in structured APIs:
value” & “value” for every dropdown & checkbox.
However, in the era of AI agents, we call this
Unset
challenge “entity resolution.”
POST /projects/67428930/members/add
{
“user_id”: “28d0b075-679b-409d-92c274d69fd0cb9e”
}
© Moveworks, Inc
moveworks.com
Unfortunately, today’s solutions for building AI
1. Every single value that’s submitted needs to be
agents can’t perform entity resolution efficiently.
manually “cleaned up.” The LLM is going to submit
They all take the same approach: In-API entity
everything from “Orion” to “Project Orion” to “the
resolution. We took a look at code samples for
Project Orion” to “PROJECT_ORION.” Developers are
building AI agents from the existing solutions. For
going to spend hours writing text processing utilities
those of you who don’t speak Typescript…
instead of building integrations.
© Moveworks, Inc
moveworks.com
2. Your AI agents will make decisions that your
get a perfect match, traditional automation tools will
users don’t expect. With in-API entity resolution,
throw an error. Users are left to brute force different
developers write “matching” code to predict which
inputs until they find one that matches – executing
business object the user is referring to. Unless you
the API over and over again.
In-API entity resolution is not the way to build
on their inputs (slots). The AI agent isn’t tasked with
AI agents. Moveworks Slot Resolvers offer a
submitting “consultant name” – it’s tasked with
different approach to the problem. Moveworks Slot
submitting a “User” object.
Resolvers allow developers to configure data types
Our Agentic Automation Engine is packed with
strategies that empower the Moveworks Copilot to
cutting-edge conversational technology like a
have conversations that “resolve” those slots with
stateful execution tracker & entity resolution
transparency & accuracy.
© Moveworks, Inc
moveworks.com
1. It automatically finds & matches slots to business
3. It allows the user to disambiguate & confirm the
objects where highly confident. In this case, it found
project they want.
a perfect match for Jim Telustria and kept the user
informed about its selection.
2. It picks an API call to execute to retrieve possible
4. It preserves system IDs between turns, without
letting the LLM accidentally corrupt / mutate the
values.
business objects (projects in this case) & presents
them to the user with relevant information &
citations so they can pick the right one.
© Moveworks, Inc
moveworks.com
To top it off, developers aren’t limited to just using
bind plugins to data types, the Moveworks Copilot is
the IDs, they can access the entire business object
able to more effectively dynamically assemble plans
in their actions. So if you need to add an additional
across plugins, and pass resources reliably from one
step that collects an approval from the project
plugin to the next.
owner, you can just reference it as “project.owner” –
developers write even less code, and end-users get
lower latency AI agents.
With this architecture, developers need to write
MUCH less code. No text formatting, no parsing, no
matching, no disambiguation, no state tracking –
Moveworks Slot Resolvers offer a truly agentic
nothing. The Agentic Automation Engine handles it
solution to the entity resolution problem. Since we
for you.
Policy Validators
Unfortunately, most AI agents today have a primitive
approach to policy validation – they feed text
When you’re building AI agents to live within your
instructions into an LLM and expect the LLM to
business – they have to be able to follow your
figure out how to enforce it.
organization’s policies. Just because it’s “powered
by AI,” doesn’t give it an excuse to follow business
rules only 70% of the time. They should always be
enforced.
© Moveworks, Inc
moveworks.com
Just because an LLM can follow instructions,
In AI agents today, you have to write this as a text
doesn’t mean they should be your system for
instruction: SalesforceAccount is required if the
enforcing instructions. LLMs are always subject
facility has an executive business center.
to misunderstanding your instructions, or worse,
a malicious user could jailbreak past the LLMs
instructions.
You are at the mercy of the LLM to understand
“if the facility has an executive business center”
and enforce it reliably. You might get lucky, but
Let’s take a simple example – booking a room.
realistically, you’re probably going to get a chat
Pretend your organization has a special policy: If you
experience like this.
book a room that has an executive business center,
you need to specify which customer you are hosting.
© Moveworks, Inc
moveworks.com
Your developers will have to become prompt-tuning
offer the correct approach. All a developer has to do
experts to get this to work as expected. Even in ideal
is specify a rule in our friendly condition syntax, and
conditions, this will only work ~70% of the time.
the conversation naturally follows the requirements.
We reject the notion that instructions are the right
See the example below:
way to enforce business policies. Policy Validators
Slot Resolver
Policy Validator
First, a Slot Resolver that converts “Guardian
Finally, our Reasoning Engine used this deterministic
conference room” into an “OfficeSpaceFacility”
check to request the name of the customer from the
object.
user. Gwen was able to reliably & accurately book
Then, our Agentic Automation Engine validates that
the room.
all requirements are met. In this case, it noticed that
When deploying AI agents, you don’t have to choose
there was a Policy Validator on the “account” slot.
between doing things fast and doing things right –
It noticed the OfficeSpaceFacility had an Executive
you can do both. Moveworks Policy Validators make
Business Center in the amenities.
that possible.
© Moveworks, Inc
moveworks.com
Action Orchestrator
What is an AI agent supposed to do with that
information? There’s nothing that allows it to recover
AI agents need to be able to ultimately take action
the conversation with the user. The user is left
in business systems. Modern SaaS tools use APIs
confused, wondering if the action actually failed, or if
to allow other systems to take action. APIs let you
the AI agent is just incompetent.
interact with business systems, but they are not an
integration themselves.
The Moveworks Action Orchestrator creates a
deeply connected bridge between the AI agent and
Every developer who has integrated with APIs before
integration code. Instead of integration code being a
understands that integrations need a little more than
black box for AI agents, the integration code is clear
just an API – code needs to be written somewhere.
& interpretable.
The Integration Platform-as-a-Service (or iPaaS)
industry was born to solve this problem. iPaaS tools
today (Zapier, Workato, Microsoft Power Automate,
ServiceNow Flow Designer, Salesforce Flow Builder,
Mulesoft, etc.) allow developers to write code that
connects APIs across business systems.
Unfortunately, these iPaaS tools and middleware are
a black box to AI agents. AI agents don’t understand
what is happening inside these automations, they
simply know what data they require and what data
they return.
So, if your automation runs into an error, all the AI
agent is going to see is an arcane error message like
this:
Javascript
{
In the example above, you notice two key benefits to
“message”: “API platform by
Workato: new api request: Calling IP
address=123.456.78.910, Access profile
ID=6745835, and Access profile
name=Production”
an integrated Action Orchestrator.
}
© Moveworks, Inc
1. Our Action Orchestrator keeps track of all the
actions that are planned, in progress, and complete.
As a result, it can offer progress updates to the user
more efficiently than traditional iPaaS & middleware.
moveworks.com
2. Further, it can interpret the actions & responses
A New Era of Automation
themselves. This means developers no longer need
to write code for dialogs, edge cases, or exception
This release brings forward our vision for
handling – the Action Orchestrator handles it for
Moveworks as the platform for AI Agents. When
them.
combined with the industry-leading Agentic
Reasoning Engine, our new Agentic Automation
Our Action Orchestrator significantly reduces the
Engine supercharges a developer’s ability to bring
amount of code needed to build great end user
new agents to life. Every persona, every SaaS appli-
experiences. Developers get to stay focused on
cation, and every line of business deserves to have
building working integrations instead of formatting
an agent powered by Moveworks.
minutiae – ultimately accelerating your ability to
build a Copilot that touches every business system.
As we look to the future, we look forward to seeing
our developer ecosystem multiply manifold and truly
deliver what enterprises need most: one copilot for
every business system.
© Moveworks, Inc
moveworks.com
© Moveworks, Inc
moveworks.com