Agent Intelligence: Intent Before Automation

Agent Intelligence: Intent Before Automation

Designing Intent-Driven Agentic Automation

Intent is the purpose behind an action — what we want to achieve, the outcome we expect, and the behaviour we want to validate. In automation, Intent provides the direction before we decide what to automate, how to automate it, or which technology to use.

When automation is driven by clear Intent, the focus shifts from simply creating automated steps to building a solution around a meaningful outcome. The Intent helps identify the right scenarios, validation points, context, and automation approach required to achieve that outcome.This becomes particularly relevant with AI-enabled development. AI can translate instructions into scenarios, code, and automation components, but the quality of that output depends heavily on how clearly the desired outcome is communicated. A clear Intent gives AI a stronger engineering direction rather than leaving the implementation open to interpretation.

For example, “Create a Playwright test for the booking flow” describes an implementation request. “Validate that a customer can successfully complete a flight booking under the expected business conditions” expresses the intent behind the automation. The difference is what we want to achieve versus what we want to build.

2. What Is Intent?

Intent is the underlying purpose behind an automation — the outcome we want to achieve and the behaviour we want to validate. It answers a fundamental question: “What should this automation accomplish?”

In an automation context, Intent can be expressed through a combination of:

• Purpose — Why are we automating this?

• Outcome — What result should the automation achieve?

• Behaviour — What user or system behaviour needs to be validated?

• Scope — What part of the application or workflow is relevant?

• Constraints — What conditions or boundaries should be considered?

• Success Criteria — How do we know the intended outcome has been achieved?

For example, consider a flight booking journey. “Automate the booking page” is too implementation-focused to represent a meaningful Intent. A clearer Intent would be:

Validate that a customer can successfully complete a flight booking with valid passenger and payment details and receive a booking confirmation.

This Intent provides direction for the automation. It helps determine what needs to be covered, what should be validated, what context is required, and eventually how the automation should be implemented.

Intent therefore acts as a bridge between the expected outcome and the automation solution. The automation is not the Intent itself; it is the means through which that Intent is validated.

And this distinction becomes particularly valuable when AI participates in automation development — because AI can help implement an Intent, but the Intent still needs to come from the engineering objective.

3. Why Is Intent Important in the AI Era?

As AI becomes part of automation development, the ability to describe what we want to achieve becomes increasingly important. AI can generate scenarios, suggest approaches, create automation code, and refine existing implementations. But without a clear objective, the generated solution may satisfy the instruction without necessarily satisfying the intended outcome.

Intent provides that missing direction. It gives AI and the engineer a common understanding of the purpose, expected behaviour, and success criteria before implementation begins. This helps move the conversation from “What code should be generated?” toward “What should the automation actually accomplish?”

Consider a simple request:

“Create an automation for customer login.”

The request leaves several questions open. Are we validating successful login? Invalid credentials? Account lockout? Session behaviour? Role-based access? The implementation may be technically correct, but the automation's actual value depends on what we intended to validate.

A more meaningful Intent could be:

“Validate that an active customer can successfully authenticate using valid credentials and reach the expected account dashboard.”

Now the objective is clearer. From this Intent, we can identify the relevant behaviour, required context, validation points, and eventually the appropriate automation implementation.

This is where Intent becomes particularly useful in AI-enabled automation: AI can assist with the implementation, but Intent provides the direction. The clearer the Intent, the easier it becomes to evaluate whether the resulting automation is actually aligned with the expected outcome.

4. How Do We Build Intent?

Building Intent starts with clearly defining what we want the automation to achieve. But Intent by itself is not the complete input for automation development. It needs to be supported by the information that allows an engineer — or an AI assistant — to understand the scenario and translate the objective into an implementable solution.

A practical Intent can therefore be built by considering the following elements:

• Purpose — What are we trying to achieve through the automation?

• Inputs — What data, parameters, or prerequisites are required?

• Steps — What sequence of actions or interactions should take place?

• Conditions — Under what conditions should the scenario be executed?

• Expected Behaviour — How should the application or system behave at each relevant stage?

• Expected Outcome — What result should confirm that the Intent has been achieved?

• Context — What application, technical, framework, data, or implementation information is relevant?

Consider a flight-booking scenario.

Intent:

Validate that a customer can successfully complete a flight booking.

To make this Intent actionable, we can provide the supporting details:

Inputs: Origin, destination, travel date, passenger details, and valid payment information.

Steps: Search for a flight → Select an available flight → Enter passenger details → Complete payment → Confirm booking.

Conditions: Flight must be available, passenger information must be valid, and the selected payment method must be supported.

Expected Behaviour: Each stage should proceed successfully and allow the customer to move to the next stage.

Expected Outcome: The booking should be completed and a confirmation should be generated.

Context: Existing application behaviour, automation framework, reusable components, test data, API/UI details, and relevant engineering conventions.

Now the Intent is no longer just a statement of purpose. It is accompanied by the inputs and information required to understand and implement the scenario.

This gives us a useful progression:

Intent → Inputs & Context → Steps & Conditions → Expected Behaviour → Implementation → Validation

The important distinction is that Intent establishes the objective, while the supporting details make that objective actionable. This becomes especially valuable when AI is involved, because the quality of AI-assisted implementation depends not only on the instruction we provide, but also on the completeness and relevance of the context surrounding it.

5. How Can Automation Be Built Using Intent?

Once the Intent is clear and supported with the necessary inputs, context, steps, conditions, and expected behaviour, it can start guiding the automation design.

The first step is to translate the Intent into automation objectives. Instead of immediately writing code, we identify what needs to be validated, which parts of the workflow require automation, and what level of automation is appropriate.

For the flight-booking example, the Intent is to validate successful completion of a customer booking. From this, the automation can be structured around meaningful validation points:

Search → Flight Selection → Passenger Details → Payment → Booking Confirmation

Each stage can then be associated with its relevant inputs, conditions, actions, and validations.

The next decision is where the validation should take place. Depending on the system and available interfaces, the Intent may be implemented through UI automation, API automation, service-level validation, or a combination of these. The Intent does not automatically dictate the technology; it helps us determine what needs to be validated, while the technical context helps determine how it should be validated.

This becomes particularly useful when AI is involved. Once the Intent and supporting context are available, AI can assist with activities such as:

• Identifying Relevant Scenarios

• Breaking Down Workflow Behaviour

• Suggesting Validation Points

• Generating Automation Scenarios

• Creating or Refining Automation Code

• Identifying Reusable Components

• Suggesting Alternative Automation Approaches

The generated solution still needs to be reviewed against the original Intent. A technically executable test is not necessarily a meaningful test if it does not validate the intended behaviour.

Therefore, the flow can be viewed as:

Intent → Understand → Decompose → Design → Implement → Validate

Here, Intent provides the objective, supporting context provides understanding, engineering decisions shape the solution, and validation confirms whether the automation actually fulfils the original objective.

6. Intent Techniques

Intent can be expressed in different ways depending on the complexity of the automation and the level of clarity required. The objective is not to create a rigid format, but to provide enough direction for the automation solution to understand what needs to be achieved and what information is relevant to achieving it.

Some practical techniques for defining Intent are:

• Outcome-Based Intent — Start with the result that the automation is expected to achieve.
  Example: Validate that a customer successfully completes a flight booking.

• Behaviour-Based Intent — Describe the behaviour that needs to be validated rather than only naming the feature.
  Example: Validate that an authenticated customer can access the booking details associated with their reservation.

• Scenario-Based Intent — Express the Intent around a specific business or user scenario.
  Example: Validate flight booking when the selected flight has available seats and the customer provides valid passenger information.

• Condition-Based Intent — Include important conditions that influence how the automation should behave.
  Example: Validate that booking is prevented when the selected flight has no available seats.

• Contextual Intent — Add the relevant technical or business context required to interpret the Intent. This may include application behaviour, existing automation patterns, test data, APIs, reusable components, or framework conventions.

• Acceptance-Oriented Intent — Define the Intent around the conditions that determine whether the expected outcome has been achieved.
  Example: A successful booking should generate a booking reference and display confirmation to the customer.

These techniques can also be combined. A complex automation requirement may need Outcome + Behaviour + Conditions + Context + Expected Result rather than relying on a single technique.

The important aspect is to avoid treating Intent as just a short sentence. Good Intent provides direction, while the supporting details provide the information required to turn that direction into an automation solution.

7. Intent Best Practices

Defining Intent is not about making the description longer. It is about making the objective clear enough to guide the automation and precise enough to avoid unnecessary interpretation. A few practices can make Intent more effective, particularly when AI is involved.

• Be Outcome-Oriented — Clearly state what the automation should achieve rather than focusing only on the feature or tool.

• Describe Relevant Behaviour — Include the behaviour that needs to be observed or validated. This helps distinguish meaningful validation from simple execution.

• Provide Necessary Inputs — Identify the data, parameters, prerequisites, or conditions required for the scenario.

• Include Relevant Context — Provide the business and technical context needed to understand the Intent. Context may include application behaviour, existing implementation patterns, framework details, reusable components, or test data.

• Define Conditions Clearly — Specify the conditions under which the intended behaviour should occur, including important positive and negative scenarios.

• Define Expected Results — Make the expected outcome observable and verifiable. This gives both the engineer and AI a basis for evaluating the implementation.

• Separate Objective From Tool Choice — Define what needs to be achieved before deciding whether UI, API, mobile, service-level, or another automation approach is appropriate.

• Keep Intent Focused — Avoid combining unrelated objectives into a single Intent. A focused Intent is easier to understand, implement, and validate.

• Validate the Intent Before Implementation — Ensure the Intent reflects the actual business or engineering objective before automation development begins.

A useful principle is:

The goal is not to provide more information; it is to provide the right information.

When Intent, context, inputs, conditions, and expected outcomes are relevant and well-structured, they provide a much stronger foundation for both human-led and AI-assisted automation development.

8. Intent vs Prompt

Intent and Prompt are closely related in AI-assisted automation, but they serve different purposes.

Intent defines what we want to achieve. A Prompt communicates an instruction or request to AI to help us achieve it.

For example:

Intent: Validate that a customer can successfully complete a flight booking with valid passenger details.

Prompt: Create a Playwright BDD scenario for the flight-booking flow using the existing Page Object Model and follow the framework's current coding conventions.

The Intent establishes the objective. The Prompt provides the instruction for the AI to perform a specific task. Therefore, a Prompt can contain the Intent along with the relevant context, inputs, constraints, and expected output required for that particular task.

The same Intent can result in multiple Prompts depending on what we need from AI. For the same flight-booking Intent, we might ask AI to:

• Generate Test Scenarios

• Create Gherkin Scenarios

• Design Page Objects

• Generate Playwright Code

• Review Existing Automation

• Suggest Additional Validation

• Analyze Automation Gaps

The Intent remains consistent, while the Prompt changes according to the task.

A simple way to understand the relationship is:

Intent = What do we want to achieve?
Context = What does AI need to know?
Prompt = What do we want AI to do with that information?

Therefore, Intent should not be confused with Prompt. A well-structured Prompt can carry the Intent and its supporting information, but the Intent remains the underlying objective that guides the automation activity.

Intent defines the objective, while the Prompt communicates the task required to work toward that objective. Understanding this distinction helps us use AI more effectively when designing and implementing automation.

9. Human-in-the-Loop

Intent becomes most effective when it remains connected to human engineering judgment. AI can help interpret an Intent, structure the required information, suggest scenarios, and generate implementation artifacts, but the human remains responsible for defining the objective and deciding whether the proposed solution is appropriate.

A practical Human-in-the-Loop flow can be represented as:

Human Defines Intent → Provides Context → AI Assists → Human Reviews → AI Refines → Human Validates

The process starts with the human understanding the business or engineering objective. The Intent is then supported with the relevant inputs, steps, conditions, expected behaviour, and technical context. AI can use this information to assist with scenario creation, automation design, code generation, or review.

Human review remains important at each meaningful stage. The generated output may need clarification, refinement, or additional context before it becomes part of the automation solution. This keeps the development process collaborative rather than treating AI as an independent implementation engine.

For example, when developing a Playwright automation, an engineer may define the Intent, provide the existing framework structure and application context, and ask AI to generate the required scenario and implementation. The engineer can then review the generated solution against the intended behaviour, provide corrections or additional context, and allow AI to refine the implementation.

The value of this approach is not simply that AI generates code faster. It creates a structured collaboration where human Intent and engineering judgment guide AI assistance throughout the automation lifecycle.

Human defines the direction. AI assists with the journey. Human validates the outcome.

10. Practical Example — From Intent to Automation

Let us bring the concept together with a practical flight-booking scenario. The objective is not to start with the automation tool or code, but to progressively translate the business objective into an automation solution.

Step 1: Define the Intent

Validate that a customer can successfully complete a flight booking with valid passenger and payment details.

This establishes the primary objective.

Step 2: Provide the Required Inputs

The Intent needs supporting information to become actionable:

• Flight Details — Origin, destination, travel date, and available flight.

• Passenger Details — Valid passenger information.

• Payment Details — Valid payment information.

• Test Data — Data required to execute the scenario.

Step 3: Define the Steps

The expected journey can then be expressed as:

Search Flight → Select Flight → Enter Passenger Details → Complete Payment → Confirm Booking

These steps provide the sequence required to achieve the intended outcome.

Step 4: Define Conditions

The scenario also needs conditions that determine whether the expected behaviour should occur:

• Flight Availability — The selected flight should have available seats.

• Valid Passenger Information — Required passenger details should be valid.

• Valid Payment — The payment method should be supported and valid.

Step 5: Define Expected Behaviour and Outcome

At each stage, the application should behave as expected and allow the customer to progress through the booking journey.

The final outcome should be:

Booking is successfully completed and a confirmation is generated.

Step 6: Determine the Automation Approach

Now that the Intent and supporting information are clear, we can determine how the scenario should be automated. Depending on the application architecture and available interfaces, this could involve UI automation, API automation, or a combination of automation layers.

The technical implementation can then use the appropriate framework, reusable components, test data, and existing engineering patterns.

Step 7: Validate the Implementation

The completed automation is reviewed against the defined Intent, steps, conditions, expected behaviour, and outcome. This ensures that the implementation is aligned with the objective rather than simply executing the defined workflow.

This example demonstrates an important principle:

Intent provides the starting point. Supporting information makes it actionable. Engineering decisions turn it into automation. Validation confirms that the automation addresses the intended objective.

This is where Intent Before Automation becomes a practical engineering approach rather than simply a way of writing better instructions.

11. Final Insights

Intent is a simple concept, but it can have a meaningful role in how we approach automation, particularly as AI becomes part of engineering workflows.

A well-defined Intent helps establish what we want to achieve before we focus on how the solution should be implemented. When combined with the right inputs, context, steps, conditions, expected behaviour, and success criteria, it provides a clearer foundation for designing automation.

The role of Intent becomes even more relevant when AI is involved. AI can assist with analysing scenarios, generating automation, suggesting implementation approaches, and refining existing solutions. However, the quality of that assistance depends on the clarity and relevance of the information provided to it.

The practical approach is therefore not to treat Intent as a replacement for detailed requirements or implementation inputs. Instead, Intent becomes the starting point that connects the objective with the information required to build the solution.

For me, the key takeaway is:

Before asking how to automate something, be clear about what you intend to achieve.

Once that clarity exists, the next steps — providing context, defining conditions, selecting the right automation approach, implementing the solution, and validating it — become much easier to structure.

Intent Before Automation is not about adding another layer to automation. It is about giving automation a clear purpose before implementation begins.

Stay tuned for the next article from rewireAdaptive portfolio

This is @reWireByAutomation, (Kiran Edupuganti) Signing Off!

With this, @reWireByAutomation has published a "Agent Intelligence: Intent Before Automation"

THE LEAP - In Practice

The Build Continues - With Design