Building an AI Agent Without Code

Building an AI agent used to mean months of engineering work, deep ML expertise, and a budget that only enterprise companies could justify. That picture has changed dramatically. Today, no-code AI tools have matured to the point where a marketing manager, operations lead, or startup founder can design, configure, and deploy a working AI agent in an afternoon. This guide walks you through everything you need to know, from understanding what an AI agent actually is to choosing the right builder, avoiding the most common mistakes, and getting to production faster than you'd expect.

What is a No-Code AI Agent (and Why Does It Matter Now)?

The term "AI agent" gets thrown around a lot, often interchangeably with chatbots, automations, and workflows. That ambiguity creates real confusion for teams trying to figure out what they actually need to build. Before you pick a tool or design a system, it helps to be precise about what an AI agent is, how it differs from the tools you might already be using, and why the no-code approach has become a credible path to production. Getting this foundation right saves you from building the wrong thing.

The Difference Between a Chatbot, a Workflow, and an AI Agent

Most teams already have some experience with chatbots or rule-based automations, and that experience can actually make it harder to understand what AI agents bring to the table. The three categories look similar from the outside but behave very differently under the hood. Clarifying the distinctions helps you choose the right tool for the right problem and avoid over-engineering a solution when a simpler one would do.

• A chatbot responds to user input using predefined scripts or decision trees. It follows a fixed path: if the user says X, respond with Y. It is fast and cheap to build, but brittle the moment a user deviates from the expected flow, it breaks down.

• A workflow automation tool (think Zapier or Make) connects apps and triggers actions based on events. It is rule-based: when a form is submitted, create a CRM record. While a workflow automation tool is powerful for structured and predictable tasks, it lacks the ability to reason, adapt, or handle ambiguity.

• An AI agent goes further. It can interpret intent, make decisions across multiple steps, use tools like web search or database lookups, and adjust its behavior based on context. It does not just follow a script; it pursues a goal. That distinction is what makes agents genuinely useful for complex, variable workflows that rule-based systems cannot handle.

What No-Code Actually Means in the Context of AI Builders

"No code" means different things on different platforms, and the gap between marketing language and reality can be significant. Some tools labeled as no-code still require you to write JSON configurations, understand API authentication, or debug webhook payloads. Understanding what true no-code looks like and where the boundaries actually are helps you set realistic expectations before you commit to a platform.

True no-code means you can build a functional, production-ready system using only visual interfaces: drag-and-drop builders, dropdown menus, form fields, and pre-built connectors. You should not need to write, read, or debug code at any point in the process.

When we talk about AI builders, "no-code" means that the way the model is set up, the instructions it follows, how the tools are connected, and the infrastructure it uses are all hidden. You decide what the agent should do, and the platform handles how it does it.

That said, "no-code" does not mean "no thinking." You still need to define clear goals, structure your inputs, and understand the logic of what you are automating. What you are freed from is the implementation layer, not the design layer. The best no-code AI tools are those that let non-technical users express complex logic without needing to translate it into programming syntax.

Who Is Building AI Agents Today and Why You Don't Need to Be a Developer

There is a common assumption that AI automation is primarily a developer concern or something the engineering team handles while everyone else waits for a ticket to be resolved. That assumption is increasingly outdated, and the teams that challenge it are moving faster than their competitors. The profile of the people building and deploying AI agents has shifted significantly over the past two years.

According to a 2024 report by Gartner, by 2026 over 80% of enterprises will have deployed some form of AI automation, and the majority of those deployments will be driven by business teams, not engineering. The tools have caught up with the demand.

Today, the people building AI agents include:

• Operations managers automating data entry and reporting pipelines
• Marketing teams building content workflows
• Customer success leads creating ticket triage systems
• HR departments automating onboarding sequences

None of these roles require programming knowledge.

What they do require is a clear understanding of the problem being solved, the data involved, and the outcome expected. The no-code AI builder handles the rest. If you can describe a process clearly enough to explain it to a new hire, you can build an AI agent to handle it.

Choosing the Right No-Code AI Builder for Your Use Case

Not all no-code AI builders are created equal. Some excel at simple single-step automations; others are built for complex, multi-agent workflows. Some are designed for developers who want to skip the boilerplate; others are genuinely accessible to non-technical users. Picking the wrong platform early is one of the most common and most costly mistakes teams make when starting their AI automation journey. This section gives you a practical framework for evaluating your options.

Key Features to Look For in a No-Code AI Platform

With dozens of AI builder platforms on the market, it can be hard to know which criteria actually matter. Feature lists are long, demos are polished, and every platform claims to be the easiest to use. Rather than comparing features in the abstract, it is more useful to anchor your evaluation in specific capabilities that directly affect whether the tool will work for your team in practice.

The most important features to evaluate are:

Pricing structure also matters, particularly whether the platform charges by agent, by run, or by seat.

Comparing Popular AI Builders: Strengths, Limits, and Pricing

Several platforms have emerged as leading options for no-code AI agent building, each with a distinct approach and target audience. Rather than declaring a winner, it is more useful to map each platform's strengths to specific use cases so you can make an informed choice based on what you are actually trying to build.

• Zapier: Has long been the default choice for workflow automation. Its AI features are maturing, but its roots in rule-based automation mean it can feel limiting when you need genuine reasoning or multi-step agent behavior. Pricing starts free and scales by task volume.

• Make (formerly Integromat): Offers more visual complexity and is better suited to branching, multi-path workflows. It is more powerful than Zapier for complex logic but has a steeper learning curve. Pricing is scenario-based.

• n8n: Open-source and self-hostable, which appeals to teams with data privacy requirements. It supports AI nodes and agent-style workflows but requires more technical comfort to configure.

• Stack AI and Voiceflow: Purpose-built for AI workflows and offer more native support for agent behavior, knowledge bases, and LLM configuration. Both have free tiers with paid plans starting around $49–$99/month.

• Caywork: For teams that want pre-built, production-ready agents rather than building from scratch, Caywork takes a different approach covered in detail in a later section.

When a General-Purpose Builder Isn't Enough and What to Use Instead

General-purpose automation platforms are excellent starting points, but they have real ceilings. Teams often hit those ceilings later than they expect after they have already invested time in building, testing, and integrating a workflow. Knowing the signs that you are approaching those limits helps you make a platform switch proactively rather than reactively.

The signs that a general-purpose builder is not the right fit typically include:

• Needing the agent to hold context across long conversations or sessions
• Requiring the agent to make decisions based on real-time data from multiple sources simultaneously
• Wanting to deploy the same agent logic across multiple channels with different configurations
• Needing robust auditability for compliance or governance reasons

When you hit these limits, purpose-built AI agent platforms are worth the switch. They are designed from the ground up for agentic behavior or retrofitted onto a workflow automation backbone.

Another scenario where general-purpose builders fall short is when speed of deployment matters more than customization. If your team needs agents up and running in hours rather than weeks, pre-built agent libraries where the core logic is already designed and tested can dramatically reduce time-to-value. The tradeoff is less flexibility in edge-case customization, which is acceptable for the majority of standard business workflows.

Step-by-Step: Building Your First AI Agent Without Code

Knowing what you want to build and actually building it are two different things. The gap between them is where most no-code AI projects stall, not because the tools are too complex, but because teams skip foundational steps that determine whether the agent will actually work in production. This section walks through the four stages of building a no-code AI agent in sequence, with the specific decisions and pitfalls that matter at each stage.

Step 1: Define Your Agent's Goal and Trigger

Every AI agent needs a clear, specific objective. This sounds obvious, but vague goals like "help with customer support" or "automate our marketing" produce agents that do a little of everything and a lot of nothing well. The first step is not opening a platform; it is writing a single sentence that describes exactly what the agent should accomplish and defining the event that starts it.

A well-defined goal has three components:

1. An action
2. A scope
3. A success condition

For example: "When a new lead is submitted via the website form (trigger), the agent should enrich the lead with company data from Clearbit, score it based on our ICP criteria, and add it to the relevant CRM pipeline stage (action) with a confidence score above 0.8 for each enrichment field (success condition)."

The trigger defines when the agent runs. Common trigger types include:

• A form submission
• A new row in a spreadsheet
• A scheduled time interval
• An incoming email
• A webhook from another system
• A manual user action

Before you configure anything in your chosen platform, write out the goal and trigger in plain language. Share it with someone who knows the workflow well. If they can point out edge cases you have not accounted for, address those now; they are far cheaper to handle at the design stage than after deployment.

Step 2: Connect Your Data Sources and Tools

An AI agent is only as useful as the data it can access and the actions it can take. The second step is mapping out every system the agent needs to read from or write to, and confirming that your chosen platform can connect to all of them. Data connectivity issues are the most common source of delays in no-code AI projects, and they are almost always discovered later than they should be.

Start by listing every data source the agent needs:

• A CRM
• A database
• A document store
• A spreadsheet
• An API endpoint
• An email inbox

Then list every action the agent should be able to take:

• Create a record
• Send a message
• Update a field
• Trigger another workflow

For each item on both lists, verify two things:

1. That your platform has a native connector
2. That the authentication method is compatible with your organization's security policies (OAuth, API key, service account, etc.)

If a native connector does not exist, most platforms support custom HTTP requests or webhooks as a fallback, but this adds complexity. Identify these gaps early.

Also consider data quality at this stage. If the agent is reading from a CRM with inconsistent field naming, missing values, or duplicate records, those issues will surface as agent errors. Cleaning the data before connecting it is almost always faster than debugging agent behavior caused by dirty inputs.

Step 3: Set Up Logic, Conditions, and Actions

Once the data connections are in place, you can build the actual decision logic of the agent. This is the step where most of the agent's value is created and where most of the complexity lives. The goal is to translate the plain-language description from Step 1 into a sequence of conditions, decisions, and actions that the platform can execute reliably.

Start with the happy path: the sequence of steps the agent should follow when everything goes as expected. Map this out visually before configuring it in the platform. Most no-code builders provide a canvas or flow editor for this purpose.

Then add conditional branches. What should the agent do if:

• A required field is missing?
• A confidence score falls below the threshold?
• An API call fails or times out?

Agents without error handling are fragile; they work in demos and break in production.

For AI-specific logic (prompt design, model selection, output parsing), most platforms provide a dedicated node or step. Keep prompts specific and grounded in the data the agent has access to. Vague prompts produce inconsistent outputs. If the agent needs to produce structured output (a JSON object, a formatted summary, a scored record), specify the exact format in the prompt and validate the output before passing it downstream.

Document the logic as you build it. Future you, or your colleagues, will thank you.

Step 4: Test, Iterate, and Deploy

Building an AI agent and deploying a reliable one are different milestones. The gap between them is testing. Teams that skip or rush testing are the ones who end up with agents that behave unpredictably in production, eroding trust in AI automation across the organization. A structured testing approach is not optional; it is what separates a proof of concept from a production system.

Start with unit testing: run the agent against a set of known inputs and verify that the outputs match expectations. Include edge cases such as missing data, unusual formatting, and boundary values.

Then test end-to-end with real data from your environment. Synthetic test data rarely captures the messiness of production inputs. Run at least 20–50 real-world examples through the agent before declaring it ready.

Monitor closely in the first week after deployment. Set up alerts for failures, unexpected outputs, or performance degradation. Most no-code platforms provide basic logging; use it.

Iterate based on what you observe. The first version of an AI agent is rarely the best version, and that is fine. The advantage of no-code tools is that iteration is fast. A prompt change, a new condition, or an adjusted threshold can be deployed in minutes. Treat the first deployment as a starting point, not a finish line.

Common No-Code AI Automation Use Cases

Understanding what AI agents can do in theory is useful. Seeing how they are applied in practice is more useful. The use cases below represent the highest-ROI applications of no-code AI automation across business functions, not hypothetical examples, but workflows that teams are actively running today. Each use case includes enough specificity to help you assess whether it is applicable to your own environment.

Lead Qualification and CRM Enrichment

Sales and marketing teams spend a disproportionate amount of time on tasks that generate no direct revenue: researching leads, updating CRM records, scoring inbound inquiries, and deciding which opportunities to prioritize. These tasks are repetitive, data-intensive, and follow consistent logic, exactly the conditions where AI agents excel. Automating them frees sales reps to focus on conversations rather than administration.

A lead qualification agent typically works as follows:

• When a new lead enters the system (via form, import, or manual entry)
• The agent pulls enrichment data from sources like Clearbit, LinkedIn, or Apollo
• Scores the lead against the ideal customer profile criteria defined by the sales team
• Assigns a tier (hot, warm, or cold)
• Routes the lead to the appropriate pipeline stage or sales rep
• Logs all actions in the CRM with a summary note

The business impact is measurable. McKinsey estimates that sales teams using AI for lead prioritization see a 10 -15% increase in conversion rates and a significant reduction in time spent on manual research.

This workflow is well within the capability of current no-code AI tools. Platforms like Zapier, Make, and Stack AI all support the necessary integrations. The primary setup investment is defining the ICP scoring criteria clearly enough for the agent to apply them consistently.

Internal Knowledge Base and Support Agents

Most organizations have a significant amount of institutional knowledge locked in documents, wikis, Notion pages, Confluence spaces, and email threads inaccessible to the people who need it most at the moment they need it. Internal support agents solve this by creating a conversational interface over existing knowledge, reducing the time employees spend searching for information and reducing the volume of repetitive questions directed at subject matter experts.

An internal knowledge base agent connects to your existing documentation sources, indexes the content, and provides accurate, sourced answers to employee questions via Slack, Teams, or a web interface. When a question falls outside the indexed knowledge, the agent escalates to a human or flags the gap for content creation.

The setup requires:

1. Identifying the primary knowledge sources
2. Configuring the retrieval system (most platforms use RAG, retrieval-augmented generation)
3. Defining the scope of questions the agent should handle
4. Setting clear escalation rules

According to Forrester, employees spend an average of 11 hours per week searching for information. Even a 20% reduction in that time produces meaningful productivity gains at scale. Internal knowledge agents are among the highest-ROI applications of no-code AI because the content already exists; the agent simply makes it accessible.

Content Generation and Approval Workflows

Content production is one of the most time-consuming functions in modern marketing and communications teams and one of the most amenable to AI augmentation. The opportunity is not to replace human creativity but to automate the mechanical, repetitive parts of the content process: drafting first versions, repurposing existing content across formats, enforcing brand guidelines, and managing approval routing.

A content generation workflow agent can be configured to:

• Take a brief (structured input) and generate a first draft
• Apply brand voice guidelines from a style guide
• Format the output for the target channel (blog, LinkedIn, email, social)
• Route the draft to the appropriate reviewer
• Incorporate feedback and regenerate
• Publish or schedule upon approval

The key to making this work is structured input. Agents that accept vague briefs produce vague content. The more specific the input like target audience, key message, tone, length, and source material—the more useful the output.

Content teams that implement these workflows report 40–60% reductions in time-to-first-draft, allowing writers to spend more time on editing, strategy, and high-judgment creative work. The agent handles the scaffolding; the human handles the craft.

Data Extraction and Reporting Pipelines

Data entry, extraction, and report generation are among the most universally despised tasks in business operations: time-consuming, error-prone, and offering zero creative value to the people doing them. They are also among the most straightforward to automate with AI agents. If your team has a recurring report that takes hours to compile manually, that is a candidate for automation.

A data extraction and reporting agent can be configured to:

• Pull data from multiple sources on a defined schedule
• Clean and normalize the data
• Perform calculations or aggregations
• Generate a formatted report or dashboard update
• Distribute it to the relevant stakeholders via email, Slack, or a shared document

For more complex extraction tasks such as pulling structured data from unstructured sources like PDFs, emails, or scanned documents, AI agents with document parsing capabilities can handle formats that traditional automation tools cannot.

The business case is straightforward. If a report takes 3 hours to compile weekly, an AI agent that automates it pays for itself in the first month. More importantly, it eliminates the risk of human error in data handling, which, in financial or compliance contexts, has costs that far exceed the time savings.

Mistakes to Avoid When Building AI Agents Without Code

No-code AI tools lower the barrier to building agents, but they do not eliminate the ways those agents can fail. In fact, because iteration is faster and easier, teams sometimes move so quickly that they repeat the same mistakes across multiple projects before identifying the pattern. The three mistakes below are the most common and the most preventable in no-code AI agent deployments.

Over-Engineering Your First Agent

The most common mistake teams make when building their first AI agent is trying to solve too many problems at once. The enthusiasm is understandable; once you see what agents can do, it is tempting to design a system that handles every edge case, integrates with every tool, and produces perfect outputs from day one. That ambition is the enemy of getting started.

An over-engineered first agent takes longer to build, is harder to debug when it fails, and is more likely to be abandoned before it reaches production. The complexity compounds:

• More integrations mean more points of failure
• More logic branches mean more edge cases to test
• More output formats mean more validation to implement

The better approach is to start with the smallest version of the agent that would still be valuable. Build the happy path only. Deploy it, measure it, and iterate. Each iteration teaches you something about the workflow, the data, and the agent's behavior that you could not have anticipated at design time.

A useful heuristic: if your first agent cannot be described in two sentences, it is too complex. Scope it down until it can. You can always expand the agent's capabilities after it is running reliably.

Ignoring Data Quality and Input Formatting

AI agents are sensitive to the quality and consistency of their inputs in ways that rule-based automations are not. A traditional automation that expects a date in MM/DD/YYYY format will simply fail if it receives DD/MM/YYYY. An AI agent might handle the variation gracefully, or it might produce a subtly wrong output that is harder to catch. Data quality issues are the leading cause of unreliable agent behavior, and they are almost always discovered later than they should be.

Before connecting a data source to an agent, audit it for the most common quality issues:

• Missing required fields
• Inconsistent formatting
• Duplicate records
• Stale or outdated values
• Encoding errors (especially for multilingual content)

For agents that accept unstructured input such as free-text descriptions, uploaded documents, and email content, define clear pre-processing steps. Stripping irrelevant content, normalizing formatting, and validating required fields before the agent processes them significantly improves output consistency.

Also consider input validation as part of the agent logic itself. If a required field is missing, the agent should either request it (in interactive contexts) or flag the record for human review rather than proceeding with incomplete information. Garbage in, garbage out is as true for AI agents as for any other system.

Building Without a Clear Success Metric

You cannot improve what you cannot measure, and you cannot justify continued investment in AI automation without demonstrating its impact. Yet many teams deploy agents without defining what success looks like in quantitative terms. Without a baseline and a target, it is impossible to know whether the agent is working, degrading, or simply creating the illusion of productivity.

Before deploying any agent, define at least one primary success metric. Depending on the use case, this might be:

• Time saved per week (in hours)
• Error rate reduction (percentage)
• Throughput increase (records processed per hour)
• Cost per output (compared to manual processing)

Measure the baseline before deploying the agent. This requires capturing the current state of the process lilke time spent, error rates, and volume handled, which is often harder than it sounds but is essential for a valid before/after comparison.

After deployment, monitor the metric weekly for the first month. Set a threshold below which you will investigate: if the agent's accuracy drops below 90%, or if processing time increases unexpectedly, those are signals that something has changed in the data or the environment that needs attention.

Success metrics also help you make the case for expanding AI automation to other workflows, a critical step in moving from a pilot project to an organizational capability.

How Caywork Takes No-Code AI Agent Building Further

Most no-code AI platforms ask you to build agents from scratch like connecting data sources, designing logic, configuring models, and testing behavior before you can deploy anything useful. Caywork takes a different approach. Instead of giving you a blank canvas, it gives you a library of pre-built, production-ready AI agents that can be deployed and customized for your specific workflows, significantly reducing the time and effort required to go from idea to running agent.

What Makes Caywork Different From Traditional AI Builders

Traditional AI builders are infrastructure tools. They give you the components, connectors, logic nodes, and model configurations and expect you to assemble them into something useful. That approach is powerful for teams with specific, complex requirements and the time to build. But for most business teams, what they need is not a build environment; it is a working agent, deployed quickly, that they can adapt to their context.

Caywork bridges this gap by combining a curated agent marketplace with a no-code configuration layer. Instead of building a lead qualification agent from scratch, you find one that already handles the core workflow, connect it to your CRM and data sources, configure the parameters specific to your business (ICP criteria, scoring weights, routing rules), and deploy it.

This approach offers several advantages over traditional builders:

Caywork's model is not just a faster way to build; it is a different model for how teams adopt AI automation.

How to Find, Configure, and Deploy Agents Instantly on Caywork

Getting started on Caywork does not require an onboarding call, a professional services engagement, or a lengthy procurement process. The platform is designed for teams that want to move quickly, and the deployment flow reflects that. From sign-up to a running agent typically takes less time than a typical planning meeting.

The process works in four steps:

1. Search or browse the agent marketplace by use case, department, or keyword. Each agent listing includes a description of what it does, what integrations it requires, and what the typical setup time looks like.

2. Select an agent and review its configuration options. Most agents expose a set of parameters like thresholds, routing rules, output formats, and connected tools that you adjust to match your context.

3. Connect your tools using Caywork's native integration library. Authentication is handled through standard OAuth and API key flows; no custom code is required.

4. Test the agent with real data using the built-in sandbox environment, then activate it. From activation, the agent runs automatically based on the triggers you have defined.

For teams that need customization beyond the default parameters, Caywork's configuration layer supports conditional logic, custom prompt modifications, and output transformations—all through visual interfaces.

Frequently Asked Questions

As no-code AI automation becomes more accessible, the questions teams ask have shifted from "Is this possible?" to "Is this right for us, and how do we get started?" The questions below reflect the most common decision points for teams evaluating whether and how to build AI agents without code, answered directly, without hedging.

1. Can I Really Build a Production-Ready AI Agent Without Coding?

Yes, with the right platform and a well-defined use case. No-code AI tools have matured to the point where genuinely complex, production-grade agents can be built and deployed without writing code. The caveat is that "no-code" does not mean "no thinking": you still need to define clear goals, clean data, and a coherent logic structure. What the platform handles is the implementation, not the design. Teams that approach no-code with that understanding consistently ship production agents. Teams that treat it as a shortcut to skipping the design phase consistently struggle.

2. What's the Difference Between No-Code AI Tools and Low-Code Platforms?

No-code platforms require zero programming knowledge; all configuration is done through visual interfaces, dropdowns, and form fields. Low-code platforms assume some technical familiarity and allow (or require) code snippets for customization, edge cases, or advanced logic. For most business users, no-code is the right starting point. Low-code becomes relevant when you need highly specific behavior that the visual interface cannot express, which, for the majority of standard business workflows, is rarely the case with modern no-code AI tools.

3. How Do I Know If My Use Case Is a Good Fit for a No-Code Approach?

A use case is a good fit for no-code AI automation if it meets three criteria:

• It is repetitive: The same process runs multiple times
• It follows consistent logic: The decisions involved are rule-based or can be expressed as clear criteria
• The data involved is accessible: You can connect the relevant sources to your platform

If your use case involves highly novel judgment calls, requires real-time interaction with physical systems, or involves proprietary data that cannot leave your infrastructure, you may need a more custom approach. For everything else, no-code tools are likely sufficient.

4. Is Caywork Suitable for Non-Technical Teams?

Yes. Caywork is designed specifically for business teams without engineering support. The platform's agent marketplace model means you are not starting from a blank canvas; you are configuring and deploying pre-built agents that already handle the core logic. The integration layer uses standard OAuth and API key authentication flows that any team member with admin access to their tools can complete. For teams that want to go further, adding custom logic, modifying agent behavior, or building something net-new, Caywork's visual configuration tools support that without requiring code.

5. How Does Caywork Compare to Other AI Builders?

The primary difference is the starting point. Traditional AI builders like Zapier, Make, or n8n give you components and expect you to assemble them. Caywork gives you pre-built, tested agents and lets you configure them for your context. This means significantly faster time-to-deployment for standard use cases, with the trade-off of less flexibility for highly custom requirements. For teams whose primary goal is deploying reliable AI automation quickly rather than building bespoke systems, Caywork's model is the more practical choice. For teams with specific, complex requirements that fall outside standard use cases, a traditional builder may offer more control.

References

• Anthropic: https://www.anthropic.com/news/what-are-ai-agents
• Gartner: https://www.gartner.com/en/documents/4006920 & https://www.gartner.com/en/newsroom/press-releases/2024-01-15-gartner-forecasts-worldwide-ai-software-market
• G2: https://www.g2.com/categories/no-code-development-platforms
• Zapier Pricing: https://zapier.com/pricing
• Make Pricing: https://www.make.com/en/pricing
• n8n Documentation: https://docs.n8n.io/
• Stack AI Pricing: https://www.stack-ai.com/pricing
• Harvard Business Review: https://hbr.org/2023/06/how-to-use-ai-responsibly
• McKinsey: https://www.mckinsey.com/capabilities/growth-marketing-and-sales/our-insights/the-state-of-ai-in-sales
• Forrester: https://www.forrester.com/report/the-future-of-knowledge-management/
• Content Marketing Institute: https://contentmarketinginstitute.com/articles/ai-content-production/
• Deloitte: https://www2.deloitte.com/us/en/pages/finance/articles/intelligent-automation-finance.html