# Welcome
Welcome to **WalnutAI**, an AI-powered application development platform that enables you to build complete applications simply by describing what you need. By turning prompts into working components, WalnutAI automatically handles requirements, logic, structure, and lifecycle management, eliminating the need for manual setup across multiple tools. It streamlines the entire development process from idea to deployment so you can create, iterate, and manage applications with minimal effort and full traceability.
By centralizing every stage of the lifecycle, WalnutAI helps teams stay connected and maintain clear traceability from the original business idea through to technical execution and delivery.
#### What does WalnutAI do?
WalnutAI unifies your development ecosystem by centralizing information from multiple sources into a structured intelligence layer. It automates the "heavy lifting" of the SDLC through a sophisticated, automated pipeline:
{% stepper %}
{% step %}
#### **Upload BRD**
Simply upload your Business Requirement Document (PDF or Docx) directly to the WalnutAI platform to begin the transformation.
{% endstep %}
{% step %}
#### **AI Processing**
Our advanced AI parses the document structure, intelligently identifying and extracting core Epics, Features, and Modules.
{% endstep %}
{% step %}
#### **Interactive Review**
Use the built-in Question-Back mechanism to verify the extracted structure, ensuring the AI You can also accomplish this simply by prompting the system perfectly captures your original intent.
{% endstep %}
{% step %}
#### **Story Generation**
WalnutAI automatically generates detailed User Stories with clearly defined Acceptance Criteria.
{% endstep %}
{% step %}
#### **Test Cases**
Associated **Test Cases** are automatically created and linked to the generated User Stories for complete validation coverage.
{% endstep %}
{% step %}
#### **Code & Deploy**
Assign generated stories to AI agents to produce code, run automated tests, and create ready-to-merge Pull Requests.
{% endstep %}
{% step %}
#### Gap Analysis
Conduct gap analysis to identify missing requirements, inconsistencies, or validation gaps across Epics, User Stories, Test Cases, and Code.
{% endstep %}
{% endstepper %}
{% hint style="warning" icon="lightbulb" %}
Just have an idea and no formal requirements? You can still get started by simply prompting the system.
{% endhint %}
#### What makes WalnutAI different?
* **Unified Workspace:** WalnutAI is an AI-powered platform that enables teams to build applications within a structured ALM framework, seamlessly guiding them from idea to technical implementation in a single unified environment.
* **AI-Driven Intuition:** Makes building software more intuitive by allowing teams to describe requirements or logic in plain language.
* **Structured Outputs:** Automatically transforms natural language inputs into structured, technical outputs that follow strict governance standards.
#### Core Capabilities
* **End-to-End Management:** Manage requirements, development, testing, execution, analytics, and delivery within a single unified platform, ensuring continuity across all stages without the need to switch between multiple tools.
* **Gap Analysis:** Analyze differences between uploaded inputs (requirements, code, test cases) and actual outputs. WalnutAI identifies inconsistencies and missing elements, providing recommended changes to maintain alignment.
* **Intelligence Hub:** A central intelligence layer that connects all lifecycle artifacts. It automates the generation, enrichment, and alignment of data across your existing tools and teams.
* **Governance & Quality Assurance:** Apply validation at every stage of development. This ensures that every step remains strictly aligned with the original business intent and quality standards.
# Quickstart
To access WalnutAI, your organization's Admin must first add you as a user to the platform. This process ensures proper security and access control for your workspace.
**How Account Setup Works**
* The admin will add you as a user with the appropriate role and permissions.
* You will receive an email containing a secure link to set your password.
* Click the link, create a password that meets the security requirements, and confirm it.
* Once your password is set, you will be redirected to the login page.
* Sign in using your email address and the newly created password to access your workspace.
{% hint style="info" %}
Want to learn about creating a new project? Go to the [Projects](/getting-started/projects) section to learn more.
{% endhint %}
# Projects
Projects serve as the foundation of your WalnutAI workspace. This section guides administrators through creating projects, configuring AI models, and importing data to build a cohesive workflow environment.
* Each project functions independently with its own requirements, development artifacts, and team members.
* Projects allow you to monitor progress at every stage, from initial planning to final delivery.
* Access to projects is role-based to ensure proper governance and control.
* **Admin Privileges:** Only Admins can create, edit, delete projects, or assign team members, ensuring secure workspace governance.
* **Standard User Access:** Users can work within their assigned projects and switch between different projects as needed, but they do not have permission to modify project-level configurations.
# Create a New Project
Creating a new project in WalnutAI is a streamlined and organized process that enables you to quickly set up your workspace, configure AI models, and optionally connect existing tools and data sources.
The setup is completed in three main steps:
* [**Project Setup & AI Model Selection:**](/getting-started/projects/create-a-new-project/project-setup-and-ai-model-selection) Define your project name and choose the AI model that will drive your project’s intelligence.
* [**External Data & Connections:**](/getting-started/projects/create-a-new-project/external-data-and-connections) Select and configure the third-party tools you want to connect to your project to import existing data.
* [**Review & Create Project:**](/getting-started/projects/create-a-new-project/finalizing-the-project-setup) Verify your project settings and finalize the creation process.
This guide walks you through each stage from project initialization and AI model to data integration and final launch ensuring your workspace is fully prepared for active use.
# Project Setup & AI Model Selection
Creating a project establishes the AI intelligence that powers WalnutAI's capabilities. You must define your workspace identity and integrate the language model that drives intelligent features.
* **Define Project Identity:** Enter a clear, descriptive Project Name that reflects the scope of your work.
* **Select LLM:** Bring your own Large Language Model to power your project’s AI capabilities.
* Supported providers include **Claude (Anthropic)**, **Gemini (Google)**, **OpenAI**, **Azure OpenAI**, **AWS Bedrock**, **Moonshot (Kimi)**, **Qwen (Alibaba)**, **DeepSeek**, **GLM (Zhipu AI)**, **Ollama**, **OpenRouter**, **Together AI**, **Groq**, and **Fireworks AI**.
{% hint style="info" %}
If you do not have your own LLM, please contact the support team for assistance.
{% endhint %}
* **Configure Credentials:** Provide connection credentials such as:
* API Key: Secure key generated from your AI provider account
* Deployment Name: Model or deployment identifier
* API Version: Applicable API version
* Endpoint: Service endpoint URL
* **Usage & Billing Controls:** Configure limits to manage costs and performance.
* Spending Limit ($): Set the maximum budget for AI usage within the project.
* Rate Limit (requests/minute): Control the number of API requests allowed per minute.
* Usage Alerts: Enable notifications when usage approaches the defined limits.
* **System Instructions:** Use this section to define how the AI should respond. For example, if you want user stories in a specific format, you can add instructions like: *“Always generate user stories in the format: As a \[role], I want \[feature], so that \[benefit].”*
* **Knowledge:** Use this to provide domain-specific information. For example, if your project is in the healthcare domain, you can add relevant terminology, compliance rules, workflows, or industry standards to guide the AI’s responses.
* **Context Documents:** Upload any related project files such as requirement documents, healthcare policies, specifications, or reference materials. These files give the AI additional context to generate more accurate and relevant outputs.
* **After completing all required fields:** Click 'Test Connection' to validate the provided credentials. Once the connection is verified, click 'Save Configuration' to activate the AI model for your project.
Your AI model is now successfully connected and enriched with project knowledge and contextual data, ready to power intelligent workflows within WalnutAI.
# External Data and Connections
**When to Use External Data & Connections:**
* Connect external tools after configuring your AI model if you want to import existing data into your project.
* If you are starting from scratch, you can skip this step and proceed with the setup.
**Connect External Tools**
* **Project Management:** Connect to [Jira](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-jira-with-walnutai) or [Azure DevOps](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-azure-devops-with-walnutai) to synchronize epics, user stories, tasks, defects and any other custom issue types automatically.
* **Design Integration:** Connect to Figma to generate user stories and test cases directly from design prototypes.
* **Code Repositories:** Connect to [GitHub](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-github-with-walnutai), [GitLab](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-gitlab-with-walnutai), [Bitbucket](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-bitbucket-with-walnutai), [Azure Repos ](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-azure-repos-with-walnutai)or [AWS CodeCommit](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-aws-codecommit-with-walnutai) to integrate your codebase.
# How to Integrate Jira with WalnutAI?
#### **Steps to Generate a Jira API Token**
* Log in to your Jira account.
* On the right side of the Jira dashboard, click on your profile icon (top right corner).
* From the dropdown, select Manage account.
* Once on your account management page, click on the Security tab.
* Scroll down to find the API tokens section and click on Create and manage API tokens.
* On the API tokens page, click the Create API token button.
* A pop-up window will appear. Provide a name for your API token.
* Generate and Copy the Token:
* After naming the token, click on 'Create'.
* Your API token will be generated and displayed. Copy the token immediately, as it won’t be shown again.
#### **Connect Jira to WalnutAI**
* Go to Integrations and select Jira.
* Enter the Jira URL, the associated email ID, and the generated API token.
* Click Test Connection to verify the credentials.
* Select the Jira project you want to connect, then click Activate & Setup to configure the project integration.
* Map the required Jira fields to WalnutAI.
* Review the configuration and click Connect to complete the integration.
{% hint style="info" %}
Refer to the [Jira Sync](/overview-and-tracking/action-item/synchronizing-requirements-with-jira) guide for the next steps on pulling and pushing requirements between Jira and WalnutAI.
{% endhint %}
# How to Integrate Azure DevOps with WalnutAI?
#### **Steps to Generate a Azure DevOps Personal Access Token**
* Sign in to your **Azure account** and open **Azure DevOps**.
* Choose your **Project**.
* Click on **'User Settings'.**
* Select **Personal Access Tokens**.
* Click **'Create New Token'**.
* Choose the required permissions.
* Generate the token and copy it.
#### **Connect Azure DevOps to WalnutAI**
* Log in to WalnutAI.
* Go to Integrations and select **Azure DevOps.**
* Enter the Azure DevOps URL, then paste the generated API token.
* Click Test Connection to verify the credentials.
* Select the project you want to connect, then click Activate & Setup to configure the project integration.
* Map the required Azure DevOps fields to the corresponding WalnutAI fields.
* Review the configuration and click Connect to complete the integration.
{% hint style="info" %}
Refer to the [Azure DevOps ](/overview-and-tracking/action-item/synchronizing-requirements-with-azure-devops)Sync guide for the next steps on pulling and pushing requirements between Azure DevOps and WalnutAI.
{% endhint %}
# How to Integrate Figma to WalnutAI?
#### **Steps to Generate a Figma Personal Access Token**
* Sign in to your Figma account.
* Click on your profile icon and select **Settings**.
* Navigate to the **Security** section.
* Under **Personal Access Tokens (PAT)**, click **Generate New Token**.
* Enter a name for the token.
* Select the required permissions.
* Click **Generate Token** and copy the generated token.
* Copy the Team ID from your Figma URL.
#### Connect Figma to WalnutAI
* Log in to WalnutAI.
* Go to Integrations, select **Figma**, then click **Configure & Connect.**
* Paste the generated Personal Access Token.
* Click Connect with Token.
* Once the connection is successful, navigate to the **Intelligence Hub** and select **Figma**.
* Enter the **Team ID**, then select the required **Project, File, and Page** from which you want to generate the Requirements or Test Cases.
# How to Integrate GitHub with WalnutAI?
#### **Steps to Generate a** GitHub Personal Access Token
* Log in to your GitHub account.
* Click on your profile picture and open the User Navigation Menu.
* Select Settings.
* Navigate to Developer settings.
* Click Personal access tokens.
* Select Tokens and click Generate new token.
* Choose the required permissions.
* Generate the token and copy it.
#### **Connect GitHub to WalnutAI**
* Log in to WalnutAI.
* Go to Integrations and select GitHub.
* Paste the copied Personal Access Token.
* Click Validate and Fetch to verify the token and retrieve repository details.
* Select the required repositories.
* Choose the relevant branches.
* Click Save to complete the integration.
* Go to the WalnutAI code editor and clone the project.
To know more about the **Code Editor**, refer to the relevant Code Editor section
# How to Integrate GitLab with WalnutAI
#### **Steps to Generate a GitLab Personal Access Token**
* Log in to GitLab
* Click your Profile Avatar
* Go to Preferences
* Click Access Tokens
* Fill in the details and choose the required permissions.
* Generate the token and copy it.
#### **Connect GitLab to WalnutAI**
* Log in to WalnutAI.
* Go to Integrations and select GitLab.
* Paste the copied Personal Access Token.
* Click Validate and Fetch to verify the token and retrieve repository details.
* Select the required repositories.
* Choose the relevant branches.
* Click Connect to complete the integration.
* Go to the WalnutAI code editor and clone the project.
# How to Integrate Bitbucket with WalnutAI?
**Steps to Generate a Bitbucket API Token**
* Log in to your Bitbucket account.
* Click your profile avatar (top right).
* Select Account settings.
* Navigate to Security → Create and manage API tokens.
* Click Create API token.
* Configure the required permissions.
* Click Create and copy the API token
#### Connect Bitbucket to WalnutAI
* Log in to WalnutAI.
* Go to Integrations and select Bitbucket.
* Paste the copied Token, then enter the email ID and username associated with your account.
* Click Validate and Fetch to verify the token and retrieve repository details.
* Select the required repositories and relevant branches.
* Click Connect to complete the integration.
# How to Integrate Azure Repos with WalnutAI?
**Steps to Generate an Azure Repos Personal Access Token (PAT)**
* Log in to your Azure DevOps account.
* Click the User Settings icon (top right).
* Select Personal access tokens.
* Click **'Create New Token'**.
* Choose the required permissions.
* Generate the token and copy it.
**Connect Azure Repos to WalnutAI**
* Log in to WalnutAI.
* Go to Integrations and select Azure Repos.
* Enter your Azure DevOps Organization URL and the copied Personal Access Token (PAT).
* Click Validate and Fetch to verify the token and retrieve the available repositories.
* Select the required Repository and Branch.
* Click Connect to complete the integration.
# How to Integrate AWS CodeCommit with WalnutAI?
**Steps to Generate AWS CodeCommit Git Credentials**
* Log in to the AWS Management Console.
* Open the IAM (Identity and Access Management) service.
* In the left navigation pane, select Users.
* Choose the IAM user that requires access to AWS CodeCommit.
* Open the Security credentials tab.
* Scroll to the HTTPS Git credentials for AWS CodeCommit section.
* Click Generate credentials (or Generate API Key, then select AWS CodeCommit, depending on your AWS console version).
* Copy the generated Git Username and Git Password, or download the credentials file. These credentials are displayed only once, so store them securely
**Connect AWS CodeCommit to WalnutAI**
* Log in to WalnutAI.
* Go to Integrations and select AWS CodeCommit
* Choose the AWS Region where your CodeCommit repositories are hosted (for example, us-east-1).
* Enter your AWS Access Key ID and AWS Secret Access Key.
* Click Fetch Repositories.
* Select the Repository you want to connect.
* Select the Branch you want to use.
* Click Connect to complete the integration.
# Finalizing the Project Setup
After configuring your data sources and importing the initial assets, review your project configuration to ensure all steps have been completed correctly.
* Click **Create Project** to complete the setup. Your workspace will be created and ready for active use.
* **Add Team Members:** Grant project access to collaborators by adding team members. Each user will be able to view, create, and manage assets based on their assigned role.
To know how to add team members, refer to the [Creating and Managing Users](/getting-started/user-management/creating-and-managing-users) section.
# Managing Existing Projects
You can manage your workstreams directly from the Projects directory, where each project provides multiple actions to help you organize and maintain your workspace effectively.
* **View & Edit Project:** Access the project to review its essential details, AI configurations, and linked data sources. Make updates or adjust the project settings as needed.
* **Delete Project:** Permanently remove the project and all associated data from the platform. This action cannot be undone.
# Managing your Profile and Assets
The **My Profile** section in WalnutAI is where you manage account settings, testing assets, and administrative tools. Whether you are updating your credentials, organizing reusable test objects, or configuring dynamic variables, everything is centralized in one place for easy access and control.
**Quick Navigation**
Jump to the section you need:
1. [Profile & Security](/getting-started/managing-your-profile-and-assets/profile-and-security)
2. [Object Repository](/getting-started/managing-your-profile-and-assets/object-repository)
3. [Variable Management](/getting-started/managing-your-profile-and-assets/variable-management)
4. [Artifacts](/getting-started/managing-your-profile-and-assets/artifacts)
5. [Recycle Bin](/getting-started/managing-your-profile-and-assets/recycle-bin)
6. [Admin Settings](/getting-started/managing-your-profile-and-assets/admin-settings)
7. [Logging Out](/getting-started/managing-your-profile-and-assets/logging-out)
# Profile & Security
Your Profile & Security area is designed to keep your account information accurate and your credentials protected. This section is divided into two key areas: Profile Information and Security.
**Understanding Your Profile Data**
Your profile contains essential information that WalnutAI uses to identify you and communicate with your team. Here's what each field represents:
* **Name & Email:** Your primary contact details used for system notifications, team collaboration, and login verification.
* **Account Status**: Shows whether your account is Active (currently in use) or Inactive (not accessed for an extended period).
* **Role:** Your assigned privilege level that determines what you can view and modify in WalnutAI (e.g., Admin, Editor, Viewer).
**Managing Your Password**
To update your password and maintain account security:
* Navigate to the Security tab within My Profile.
* Follow the prompts to create a new password.
* Confirm the change and log in with your updated credentials.
{% hint style="warning" %}
We recommend changing your password every 90 days to maintain optimal security. If you suspect any unauthorized access to your account, reset your password immediately and contact your Admin for assistance.
{% endhint %}
# Object Repository
The Object Repository serves as your centralized library for all UI elements used in your test cases. By storing objects here, you create reusable components that can be referenced across multiple tests, saving time and ensuring consistency when UI changes occur.
**Creating a New Object**
To add a new UI object to your repository:
* Click Add Object to open the configuration form.
* Fill in the following properties:
* Object Type: Specifies the element's behavior and how WalnutAI should interact with it (e.g., Web, Text Input, Dropdown, Checkbox).
* Page Name: Groups related objects by their location in the application, making them easier to find (e.g., Login Screen, Checkout Header, Dashboard Sidebar).
* Description: Provides helpful context for your team about the object's purpose (e.g., "Submit button on the payment confirmation modal").
* Attributes: The technical locators WalnutAI uses to identify the element during test execution (e.g., XPath, CSS Selector, ID, Name).
* Click Create to add the object to your repository.
**Maintaining Your Objects**
Updating Attributes: When a UI element changes in your application (such as a button ID or form field), simply update the Attribute value in the Object Repository. All test cases referencing this object will automatically use the updated locator, eliminating the need to modify each test individually.
**Attribute Preference:** Enable the toggle for an attribute to set it as the default. When the test case is executed, WalnutAI will attempt to locate the element using the default attribute first before trying other available attributes.
# Variable Management
The Variable Management section is your centralized hub to create, view, edit, and manage all variables across your workspace. Variables allow you to store reusable values that can be referenced throughout your workflows, tests, and configurations, ensuring consistency and ease of updates.
**Creating a New Variable**
Follow these steps to define a new reusable value:
* Initiate Creation: Click Create Variable (or Add New Variable).
* Fill in Details:
* Variable Name: Enter a unique, meaningful name (e.g., userResponse, apiToken).
* Value: Input the specific data you want to store.
* Variable type:
* **Global Variables**
* Definition: Global variables are static values that are accessible across all test cases within a specific project.
* Scope: These variables remain constant throughout the project environment unless they are manually updated by a user.
* Use Case: They are used to ensure consistency and avoid repeated data entry for common data such as environment URLs, person names, phone numbers, or email IDs.
* **Runtime Variables**
* Definition: Runtime variables are dynamic values generated or stored automatically during the execution of a test.
* Scope: These variables are accessible across different test cases within the same execution flow, but their values typically get overwritten every time a test runs.
* Use Case: They are essential for maintaining continuity in a workflow where one step generates data required for subsequent steps, such as an Order ID, Transaction ID, Session Token, or Reference Number.
* **Local Variables**
* Definition: Local variables are test case-specific data points confined to a single individual test case.
* Scope: Access is restricted exclusively to the test case in which they are defined; they are not shared with other test cases in the project.
* Use Case: They are used for temporary or unique data to keep test logic isolated and maintain modularity, ensuring that case-specific values do not interfere with the broader project data.
* Description: Add a brief explanation of the variable's purpose to help your team.
* Add Variable: Click 'Add Variable'. The variable is now ready for use across the platform wherever variables are supported.
**Managing Existing Variables**
To edit a variable, locate it in the list and click **Edit**, update the required details, then click **Save** to apply the changes across all references. To delete a variable, click **Delete** and confirm the action to permanently remove it, as this cannot be undone.
{% hint style="warning" %}
Note: Deleting a variable may impact workflows or tests where it is currently referenced. Always ensure the variable is no longer required before proceeding with deletion.
{% endhint %}
# Artifacts
The **Artifacts** feature enables teams to centrally store and manage files required during test execution. Instead of using local file paths, which are accessible only on the creator's machine, files can be uploaded as artifacts and referenced within test cases using an **Artifact ID**. This ensures that all team members can successfully execute the same test case without modifying file paths.
**Why Use Artifacts?**
* Eliminates dependency on local file paths.
* Makes files accessible to all project members.
* Ensures consistent test execution across different systems.
* Simplifies collaboration by maintaining a centralized repository of files.
**Uploading an Artifact**
* Log in to WalnutAI.
* Click your **Profile (Name)** icon in the top-right corner of the application.
* Select **Artifacts** from the dropdown menu.
* Click **Upload**, then browse and select the required file from your local system.
* Once uploaded, the file appears in the Artifacts list.
* Each uploaded file is assigned a unique **Artifact ID**, which is used to reference the file within test cases.
**Using an Artifact in a Test Case**
* Open the required test case.
* Type **/** and select the **Upload** action. The **Upload** action is added to the test step.
* Once the **Upload** action is added, a **file\_path** field is created in the **Test Data** section. Enter the required **Artifact ID** in the **file\_path** field.
* During execution, WalnutAI retrieves the corresponding file from the Artifacts repository and uploads it automatically.
**Uploading an Artifact from Within a Test Case**
* If the required file has not yet been uploaded, you can upload it directly from the test case.
* After adding the **Upload** action, a **file\_path** field is created in the **Test Data** section.
* Click the **file\_path** field and select **Upload File Artifact**.
* Browse and select the required file from your local system.
* Once the upload is complete, the **Artifact ID** is automatically generated and populated in the **file\_path** field.
* The uploaded file is added to the **Artifacts** repository and can be reused by all project members in any test case.
# Recycle Bin
The **Recycle Bin** provides a safety net for deleted items by temporarily storing them for **30 days** before they are permanently removed. Instead of being deleted immediately, **test cases** and **action items** are moved to the Recycle Bin, allowing administrators to restore them whenever required within the retention period.
This feature helps prevent accidental data loss and ensures important work can be recovered if deleted unintentionally.
**Key Benefits**
* Prevents accidental loss of test cases and action items.
* Enables quick recovery of deleted work.
* Gives administrators centralized control over data restoration.
* Reduces the risk of permanent data loss through accidental deletion.
#### Accessing and Restoring Deleted Items
1. Click your **Profile (Name)** icon in the top-right corner of the application.
2. Select **Recycle Bin** from the dropdown menu.
3. The Recycle Bin displays all deleted **Test Cases** and **Action Items** that are available for recovery.
4. Locate the deleted item you want to restore.
5. Click **Restore**.
4. The selected item is restored to its original location and becomes available for use again.
{% hint style="info" %}
**Important:** Although users with the appropriate permissions can delete test cases and action items, **only Project Administrators** can access the Recycle Bin and restore deleted items.
{% endhint %}
# Admin Settings
Admin Settings provides high-level organizational controls and is accessible only to users with Admin privileges. This area allows you to manage the foundational structure of your WalnutAI environment.
**What You Can Do in Admin Settings**
With Admin access, you have the authority to perform the following actions:
1. Manage Organization Controls: Configure organization-wide settings that affect all users and projects, ensuring consistent policies and governance.
2. Define Roles & Permissions: Create custom roles and assign granular permissions that determine what each user can view, create, edit, or delete within the platform.
3. Create Projects: Set up new projects and define their associated workflows, ensuring teams have the proper structure to organize their testing activities.
4. Configure Action Items: Establish the framework for tracking work, including custom fields, statuses, and priorities for Epics, Features, User Stories, Defects, and Tasks.
{% hint style="info" %}
Admin Settings is your gateway to maintaining a well-organized, secure, and efficient testing environment for your entire organization.
{% endhint %}
# Logging Out
When you've finished your session, it's important to log out securely to protect your account and organizational data.
**To log out:**
1. Click on your user menu (typically located in the top-right corner).
2. Select Log Out from the dropdown options.
You'll be safely signed out and returned to the login screen. Your work is automatically saved, so you can pick up exactly where you left off when you return.
# User Management
The User Management section provides control over user accounts, roles, and permissions, allowing you to manage team members and define their access levels within the organization. This centralized directory ensures that the right people have the right access to the right projects.
To access the User Management module, navigate to Admin Settings from the main menu and locate the User Management option. Click Configure to open the directory where all active users and defined roles are listed for easy management and review.
Quick Navigation
Jump to the section you need:
1. [Creating and Managing Users](/getting-started/user-management/creating-and-managing-users)
2. [Managing Roles and Permissions](/getting-started/user-management/roles-and-permissions)
# Creating and Managing Users
The User Creation process is designed to get your team started quickly while ensuring they only have access to the projects relevant to their work. This controlled approach maintains security while enabling efficient collaboration.
**Adding a New User**
Follow these steps to create a new user account:
* Click **Add User**, then enter the required user details.
* Fill in the following fields:
* Full Name: The user's legal name for identification and display throughout the platform.
* Email & Username: Primary credentials used for system notifications, login authentication, and team communication.
* Role: The assigned privilege level (e.g., Admin, Editor, Viewer) that determines their capabilities and access rights within WalnutAI.
* Project Access: Specific project environments the user is authorized to view, edit, or manage.
* **Assign a Role:** Choose the appropriate permission template from the dropdown menu. Select a role that matches the user's responsibilities within your organization.
* **Grant Project Access:** Select the specific projects the user should be able to view or edit. Users will only see projects they've been granted access to, keeping their workspace focused and organized.
* **Finalize Account Creation:** Click Create User to complete the process. An automated email will be sent to the user's email address, providing instructions to securely set up their account credentials.
**Managing Existing Users**
**User Directory:** All existing users are listed in the User Directory section, providing a complete view of your organization's accounts. You can search, filter, and review user details from this centralized location.
**Updating User Profiles:** To modify user details, select an existing user from the directory list. You can edit their role assignment, contact information, or project access levels. Click Save to apply changes instantly. Updated permissions take effect immediately, ensuring users always have appropriate access.
# Roles and Permissions
Roles act as standardized templates, allowing you to manage access for groups of users simultaneously rather than configuring permissions individually. This approach ensures consistency and simplifies administration as your team grows.
**Why Use Roles?**
Defining roles (such as "Admin", "Manager", or "Viewer") ensures consistency across your organization and makes it simple to revoke or grant high-level access as your team scales. When you update a role's permissions, all users assigned to that role automatically inherit the changes, eliminating the need to update each user individually.
**Creating a New Role**
To define a new role, click Add Role under the Role Management tab and configure the following properties:
* Role Name: A unique, descriptive label identifying the job function or responsibility level (e.g., "Lead Automation Engineer," "Test Manager," "Read-Only Analyst").
* Description: A clear summary providing context for other administrators regarding the role's purpose, typical users, and intended use cases.
* Permissions: Granular checkboxes used to toggle specific access levels (View, Create, Edit, or Delete) for system assets such as test cases, requirements, defects, and projects.
**Managing Role Permissions**
Role Listing: All created roles and their associated permissions are displayed in the Roles section for easy review. You can quickly see which roles exist in your organization and what capabilities each role provides.
Modifying Permissions: To update a role's capabilities, navigate to Permissions, select the role you want to modify, and adjust the permissions by checking or unchecking the relevant access level boxes. Click Save to apply your changes. All users assigned to the updated role will immediately receive the new permission set.
# Action Item
Action Items are trackable units of work created to ensure that project tasks, requirements, and issues are properly addressed and completed. They represent actionable work that requires clear ownership, focused attention, and consistent follow-through.
In WalnutAI, Action Items act as a central hub for tracking and managing all project deliverables, including Epics, Features, User Stories, Defects, and Tasks. This unified system ensures every requirement is documented, assigned, and monitored through to completion.
**Types of Action Items**
WalnutAI provides a unified system for managing several distinct work types:
* **Epic:** A large body of work representing major business objectives or high-level initiatives that can be broken down into smaller deliverables like Features or User Stories.
* **Feature:** A functional component or capability that delivers specific business value, usually derived from an Epic and divided into multiple User Stories.
* **User Story:** A requirement written from the end user's perspective defining specific functionality (e.g., “As a \[user], I want \[functionality], so that \[benefit]”).
* **Task:** Technical or operational activities required to complete a User Story, Feature, or Defect, usually assigned to team members for completion within a single sprint.
* **Defect:** A bug or issue where the system deviates from defined requirements; these are logged, prioritized, and tracked until resolved.
# Creating Action Items
The Action Items hub allows you to define the hierarchy of your project. Whether you are setting a high-level Epic or a specific technical Task, the process is streamlined to ensure all mandatory data is captured.
**Creating Different Item Types**
* Click **'Add Item'** and select the specific item type from the dropdown menu (Epic, Feature, User Story, Defect, or Task).
{% hint style="info" %}
You can also import or create Epics, Features, or User Stories directly from the [Intelligence Hub.](/core-features/intelligence-hub/generate-user-stories)
{% endhint %}
* Fill in all required fields in the pop-up form:
* **Title & Type:** Enter a clear, descriptive name and confirm the correct classification to ensure proper organization within the project hierarchy.
* **Status & Priority:** Select the current progress stage (To Do, In Progress, Done) and define the urgency level (High, Medium, Low) to support workflow tracking and sprint prioritization.
* **Assignee:** Choose the specific team member responsible for completing the item, ensuring clear ownership and accountability.
* **Story Points:** Provide the effort estimation to support sprint planning and capacity management.
* **Description:** Add detailed information explaining the objective, scope, or issue for complete clarity.
* **Acceptance Criteria:** For User Stories define the specific conditions that must be met for the story to be considered complete.
* **Test Case:** For defects link the associated test case from which the defect was identified to maintain validation traceability.
* **Attachments:** Upload supporting documents, screenshots, or design files for full context.
* Click **'Save'** to create the action item.
Once saved, the Action Item will appear in the directory. If a **Task or Defect** is assigned to a team member, it will automatically reflect on their [Workboard](/overview-and-tracking/workboard), providing real-time visibility into workload and progress tracking.
# Managing Your Action Items
You can manage your Action Items directly from the directory view to streamline your workflow. This centralized hub allows for quick updates and structural organization without navigating away from the main list.
**Direct Directory Management**
Use the dropdown options within the directory view to update key fields instantly:
* **Attributes:** Update the Status, Priority, Assignee, and other attributes without opening the individual item.
* **Edit:** Click Edit to make detailed changes to the Action Item’s content or metadata.
* **Delete:** Click Delete to permanently remove the Action Item from the project.
**Organizing with Folders**
To improve structure and clarity, you can group related Action Items into folders. This is particularly useful for organizing work based on specific releases, modules, sprints, or any custom workflow structure.
**Steps to Create a New Folder:**
* Click Add Folder within the Action Items module.
* Enter a Title and Description that clearly identifies the folder's purpose.
* Drag and drop the associated Action Items (such as specific User Stories or Features) to the folder.
**Quality Insights & Traceability Overview**
* **Quality & Tracking:** Provides teams with a real-time health check of the User Story. By viewing the quality score, test case pass/fail status, and linked defects in one place, stakeholders can instantly understand implementation readiness, risk areas, and validation progress. This eliminates guesswork and ensures no failed validations are overlooked before release.
* **Metadata:** Automatically capturing details like Created By, Last Updated By, and Last Updated Date ensures full traceability. It promotes accountability and provides clear visibility into who made changes and when, which is especially valuable during audits, reviews, or when investigating requirement shifts.
* **Attachments:** Keeping requirement documents, designs, screenshots, and supporting files directly within the User Story ensures complete context in a single place. This reduces dependency on external tools, prevents information loss, and enables teams to quickly reference everything they need without searching across multiple platforms.
# AI-Driven Requirement Enhancement & Test Generation
**Using AI to Enhance the Story**
The Chat with AI option is useful for identifying and filling gaps within your User Story. Whether you missed a specific step, overlooked an edge case, or feel the acceptance criteria are incomplete, you can use the chat to refine and strengthen the requirement before it moves to development.
**You can use it to:**
* **Improve Clarity:** It rewrites unclear or ambiguous descriptions into precise, implementation-ready statements that are easy for developers to follow.
* **Enhance Criteria:** It defines acceptance criteria to make them specific, measurable, and testable.
* **Add Edge Cases:** It identifies missing scenarios, validations, and boundary conditions that may have been overlooked during initial planning.
* **Suggest Points:** It evaluates the scope and complexity of the requirements to recommend appropriate story points for better sprint estimation.
When the AI suggests enhancements, click **Apply Changes** to automatically update the story with the refined version. It replaces existing content with the AI-enhanced updates, ensuring changes are saved and immediately reflected in the User Story.
**Generating Test Cases**
You can bridge the gap between requirements and validation by leveraging automated test generation.
* **Initiate Generation:** Click **AI Generate** within the User Story interface.
* **Automated Creation:** The system automatically creates both positive and negative test cases based on the provided story details and criteria.
* **Review and Refinement:** Review the generated test cases for accuracy, then click **Confirm** & **Save** to finalize them.
* On saving, the test cases are linked to the User Story.
# Synchronizing Requirements with Jira
Jira Sync enables seamless synchronization of requirements between WalnutAI and Jira, ensuring both platforms remain up to date without manual effort. You can configure one-way or two-way synchronization based on your workflow, allowing requirements to be pulled from Jira, pushed from WalnutAI, or synchronized bidirectionally in real time. This helps maintain consistency, improves collaboration between business, development, and QA teams, and eliminates duplicate work.
**Steps for Jira Synchronization**
* Navigate to **Admin Settings**
* Select the '**Jira Sync Configuration'** option.
* Select the **WalnutAI project** that is connected to Jira.
* Choose the required sync direction:
* **WalnutAI → Jira**: Enable **Push changes to Jira** to sync requirements from WalnutAI to Jira.
* **Jira → WalnutAI**: Enable **Pull changes from Jira** to import requirements from Jira into WalnutAI.
* **Bidirectional Sync**: Enable both toggles to keep requirements synchronized between Jira and WalnutAI.
* Click **Sync**, then select **Start Sync** to begin the synchronization.
* Monitor the real-time sync progress using the **Pulled from Jira** and **Pushed to Jira** progress indicators.
* Once the sync is complete, review the synchronization summary showing the total number of items pulled and pushed.
* Navigate to **Action Items** in WalnutAI to view the synchronized requirements. The same requirements will also be available in Jira.
* With **Live Sync** enabled, any new or updated requirements created in either WalnutAI or Jira will automatically synchronize with the other platform.
* To disable Live Sync, return to **Admin Settings** and turn off the required sync toggle.
**Delete Behaviour**
WalnutAI provides three options for handling deleted requirements during synchronization:
* **Unlink** – Removes the association between WalnutAI and Jira without deleting the Jira issue.
* **Transition to Done/Closed** – Marks the linked Jira issue as **Done** or **Closed** instead of deleting it.
* **Delete Jira Issue** – Permanently deletes the linked Jira issue when the requirement is deleted from WalnutAI.
Choose the delete behavior that best matches your team's workflow before enabling synchronization.
# Synchronizing Requirements with Azure DevOps
Azure DevOps Synchronization enables seamless synchronization of requirements between WalnutAI and Azure DevOps, ensuring both platforms remain up to date without manual effort. You can configure one-way or two-way synchronization based on your workflow, allowing work items to be pulled from Azure DevOps, pushed from WalnutAI, or synchronized bidirectionally in real time. This helps maintain consistency, improves collaboration between business, development, and QA teams, and eliminates duplicate work.
**Steps for Azure DevOps Synchronization**
* Navigate to **Admin Settings.**
* Select the '**Azure** **Sync Configuration'** option.
* Select the **WalnutAI project** that is connected to Azure DevOps.
* Configure the required sync direction:
* **WalnutAI → Azure DevOps** – Push requirements from WalnutAI to Azure DevOps.
* **Azure DevOps → WalnutAI** – Pull work items from Azure DevOps into WalnutAI.
* **Bidirectional Sync** – Enable both options to synchronize changes in both directions.
* Click **Sync**, then select **Start Sync** to begin the initial synchronization.
* Monitor the real-time synchronization progress until the sync is complete.
* Navigate to **Action Items** in WalnutAI to view the synchronized requirements. The same requirements will also be available in Azure DevOps.
* Keep **Live Sync** enabled to automatically synchronize new and updated requirements between WalnutAI and Azure DevOps.
* To stop automatic synchronization, navigate back to **Azure DevOps Sync Configuration** and disable the **Live Sync** toggle.
**Delete Behavior**
WalnutAI provides three options for handling deleted requirements during synchronization:
* **Unlink** – Removes the synchronization link without deleting the corresponding Azure DevOps work item.
* **Transition to Done/Closed** – Marks the linked Azure DevOps work item as **Done** or **Closed** instead of deleting it.
* **Delete Azure DevOps Work Item** – Permanently deletes the linked Azure DevOps work item when the requirement is deleted from WalnutAI.
Choose the delete behavior that best aligns with your team's workflow before enabling synchronization.
# Dashboard
The Dashboard is the primary screen you see immediately after logging into WalnutAI. It acts as a high-level snapshot of your work, projects, and recent activity, allowing you to grasp the current state of your entire workspace at a single glance.
#### What’s on the Dashboard?
The Dashboard is organized into four key areas designed to provide maximum context with minimum navigation:
* **Key Metrics Cards:** Instant summary cards that display critical data points:
* **Total Projects:** The number of active workspaces you can access.
* **User Stories:** A count of requirements within your selected project.
* **Team Members:** The total number of collaborators assigned.
* **My Action Items:** A dedicated count of tasks specifically assigned to you.
* **Active Projects Section:** A list of your current workstreams. Each card shows the project name, its status (e.g., Active or Configuring Uploads), and the scale of the project in terms of stories and members.
* **Organization Panel:** Provides your professional profile context, including the Organization Name, your Access Level (e.g., Admin or Member), and your registered email identity.
* **Recent Activity Feed:** A live stream of modifications across your projects, including configuration changes, AI model updates, and edits made by your collaborators.
#### Why the Dashboard is Useful
The Dashboard is designed to streamline your workflow by focusing on four core benefits:
* **Centralized Visibility:** It consolidates information from multiple modules into one screen, so you don't have to hunt for data.
* **Operational Efficiency:** It saves significant time by reducing manual navigation through menus to find project statuses.
* **Smart Prioritization:** By highlighting "My Action Items" and the "Recent Activity" feed, it helps you immediately identify what requires your attention first.
* **Team Transparency:** It improves alignment by showing real-time updates and team modifications, ensuring everyone stays informed of the latest project shifts.
# Workboard
The Workboard in WalnutAI acts as your personal task management dashboard, like a to-do list. It provides a consolidated view of all items assigned to you across multiple modules, helping you stay organized and focused on your priorities.
Assigned items displayed on your Workboard may include Tasks, User Stories, Defects, and Execution Plans. The Workboard enables you to efficiently track and manage your responsibilities within the selected project, ensuring nothing falls through the cracks.
**Key Features**
**View Assigned Items**
Your Workboard displays all work items assigned to you, organized by item type (Task, User Story, Defect, Execution Plan, etc.). Each item card shows key details at a glance, including:
* **Title:** The name of the work item
* **Status:** Current progress (such as To Do, In Progress, or Done)
* **Due Date:** Deadline for completion (if applicable)
* **Priority:** Urgency level of the item
This quick-reference view helps you understand your workload and identify urgent items without opening each task individually.
**Status Updates**
You can update the status of work items directly from the Workboard without navigating away to detailed views. Status changes can be made easily using drag-and-drop functionality, allowing quick updates and smooth progress tracking. Simply drag an item card to a different status column to update its current state, and the change is reflected immediately across the platform.
**AI-Powered Insights**
Based on your workboard, WalnutAI provides a real-time overview of task progress and priority distribution across all items. It summarizes key metrics such as overall completion rate, the number of high-priority items requiring attention, and the current status of ongoing work. This section helps users quickly assess whether tasks are on track, identify any critical gaps or delays, and understand where focus is needed.
**How to Use Workboard**
Navigate to Workboard from the left-hand panel in the main navigation. By default, all items assigned to you are displayed, giving you a complete view of your current responsibilities.
Track progress or update item status directly by clicking on any item card to view details or by dragging cards between status columns to reflect progress. Use the Workboard daily as part of your workflow to stay informed about pending tasks, upcoming deadlines, and shifting priorities.
**Benefits of Using Workboard**
The Workboard provides a centralized view of all assigned work, eliminating the need to search across multiple modules or screens to find your tasks. This consolidation improves personal productivity by reducing context-switching and keeping your focus on execution.
You gain real-time visibility into work status, allowing you to quickly assess what's complete, what's in progress, and what's waiting to start. The Workboard also provides quick access to item details and updates, enabling you to respond rapidly to changing priorities or team requests without losing momentum.
# Intelligence Hub
The **Intelligence Hub** serves as the central workspace of the WalnutAI platform, enabling you to generate structured user stories and test cases from multiple input sources. Whether you're working with requirement documents, design files, code repositories, automation frameworks, multimedia content, or live application workflows, the Intelligence Hub leverages AI to transform them into actionable project artifacts while maintaining traceability across the software development lifecycle.
From this module, you can perform the following key activities:
* **Document-Driven Generation:** Upload requirement documents such as BRDs, FRDs, SRS, or spreadsheets to automatically generate structured user stories and comprehensive test cases.
* **Multimedia Requirement Extraction:** Import audio or video recordings of client meetings, product demos, or requirement discussions to extract functional requirements and generate corresponding user stories and test cases.
* **Design-Based Generation:** Connect Figma projects to analyze design frames and generate user stories and test cases directly from UI/UX designs.
* **Code Repository Analysis:** Integrate GitHub, GitLab, or Bitbucket repositories to derive functional requirements and generate user stories and test cases based on the application's source code.
* **Automation Framework Import:** Import existing Playwright automation projects from Git repositories, ZIP archives, or script files to generate documentation and test artifacts from automation assets.
* **Live Workflow Recording:** Capture real-time user interactions through Smart Recording and automatically convert recorded application workflows into structured and executable test cases.
# Generate User Stories
The **User Stories** tab within the Intelligence Hub enables you to generate structured **Epics, Features, and User Stories** from multiple input sources through a unified workflow. Whether your project information comes from **documents, audio or video recordings, Figma designs, Playwright projects or connected code repositories.** WalnutAI leverages AI to transform these inputs into well-defined and actionable requirements.
You can also interact with the **WalnutAI Chatbot** to create, modify, or refine your generated user stories and test cases. This allows you to improve descriptions, update acceptance criteria, restructure stories, add missing details, and make any necessary refinements before finalizing them.
{% hint style="info" %}
**Note:** It is mandatory to click **Save** to retain the generated content. If you do not save, the generated **Epics, Features, User Stories, and Test Cases** will be discarded and will no longer be available.
{% endhint %}
After saving:
* **Epics, Features, and User Stories** are available in the **Action Items** module.
* **Test Cases** are available in the **Test Cases** module.
# Files (Requirements-to-Story)
**When to Use Requirements-to-Story Conversion:**\
Use this feature when you have static requirements (such as BRDs, specifications, presentations, or spreadsheets) and want to automatically convert them into structured Epics, Features, User Stories, and Test Cases within WalnutAI.
* **Supported Formats:** `PDF`, `DOCX`, `XLSX`, `CSV`, `MD`, `PPTX`, `PPT`.
* **Maximum File Size:** 10 MB.
**Steps to Generate:**
* Click the **link** icon under the **Stories** tab.
* Select the **Document** option.
* Upload a supported file from your local device.
* The AI agent analyzes the uploaded document and generates **Epics, Features, and User Stories** based on the extracted requirements.
{% hint style="info" %}
Select a generated User Story and click Use in Chat to generate the related test cases.
{% endhint %}
* Click **Save** to store the generated **Epics, Features, User Stories, and Test Cases**.
{% hint style="info" %}
Result: Saved Epics, features and User Stories reflect in Action Items, while Test Cases appear in the Test Cases module.
{% endhint %}
# Media (Audio/Video to Requirement)
**When to Use the Media Feature**
The Media feature is most effective when you have raw, unstructured information captured in audio or video format. Instead of manually transcribing recordings and drafting requirements, this feature helps bridge the gap between conversations and a structured project backlog.
* **Supported Video Formats:** MP4, MOV, MKV
* **Supported Audio Formats:** MP3, WAV, M4A
* **Maximum File Size:** 100 MB
**Steps to Generate:**
* Click the **link** icon under the **Stories** tab.
* Select the **Audio / Video** option.
* Upload a supported audio or video file from your local device.
* The AI agent transcribes and analyzes the uploaded content to generate **Epics, Features, and User Stories** based on the extracted requirements.
{% hint style="info" %}
Select a generated User Story and click Use in Chat to generate the related test cases.
{% endhint %}
* Click **Save** to store the generated **Epics, Features, User Stories, and Test Cases**.
{% hint style="info" %}
Result: Saved Epics, features and User Stories reflect in Action Items, while Test Cases appear in the Test Cases module.
{% endhint %}
# Code (Repository-to-Requirement)
The **Code** option within the Intelligence Hub allows you to generate structured **Epics, Features, and User Stories** directly from your application's source code. This feature analyzes your connected repository to derive functional requirements, eliminating the need to manually document existing application functionality.
#### When to Use Code-Based Requirement Extraction
Use this option when your application's functionality is already available in a connected source code repository. WalnutAI analyzes the repository and automatically generates structured **Epics, Features, and User Stories**, making it easy to document existing applications, legacy systems, or projects with limited functional documentation.
* **Existing Connection:** If a repository was configured during project setup ([GitHub](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-github-with-walnutai), [GitLab](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-gitlab-with-walnutai), [Bitbucket](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-bitbucket-with-walnutai), [Azure Repos](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-azure-repos-with-walnutai), or [AWS CodeCommit](/getting-started/projects/create-a-new-project/external-data-and-connections/how-to-integrate-aws-codecommit-with-walnutai)), it will automatically appear under the **Code** option in the Intelligence Hub.
* **Open the Code Repository:** Click the **Code** icon in the Intelligence Hub to view the list of available repositories.
* **Select a Repository:** Choose the repository you want to use. The selected repository is automatically attached to the WalnutAI Chat for analysis.
* **Generate Requirements:** Enter your prompt in the chat and click **Generate**. WalnutAI analyzes the repository and generates structured **Epics, Features, and User Stories** based on the application's source code.
* Review the generated requirements and refine them as needed using the Chat panel. You can modify descriptions, acceptance criteria, or story details before saving the generated Epics, Features, and User Stories.
{% hint style="info" %}
Select a generated User Story and click Use in Chat to generate the related test cases.
{% endhint %}
* Click **Save** to store the generated Epics, Features, User Stories, and Test Cases.
{% hint style="info" %}
Result: Upon saving, items are stored in Action Items, and Test Cases populate the Test Cases page.
{% endhint %}
# Generate Test Cases
The **Generate Test Cases** section within the **Intelligence Hub** enables you to create structured and execution-ready test cases from multiple input sources within a unified workflow. Whether your testing inputs originate from **Smart Recording**, existing automation scripts, integrated tools, or connected code repositories, this module transforms them into well-defined and actionable test cases.
By selecting **Generate Test Cases**, you can choose the appropriate source where you can initiate [**Smart Recording**](/core-features/intelligence-hub/generate-test-cases/smart-recording), import [**Automation Scripts**](/core-features/intelligence-hub/generate-test-cases/scripts-script-to-test-case-conversion), analyse a connected [**Code Repository**.](/core-features/intelligence-hub/generate-test-cases/code-repository-to-test-case) The system processes the selected input and converts it into structured test cases with
* Test Steps: Organizes testing into logical, step-by-step actions
* Validations & Parameters: Adds relevant criteria and data inputs for accurate testing
* Visual Aids: Includes screenshots (where applicable) to improve clarity
* Test Coverage: Ensures complete testing by generating both positive and negative scenarios
You can also interact with the **WalnutAI Chatbot** to create, modify, refine, or enhance the generated test cases. This allows you to add additional scenarios, improve validations, optimize test steps, or regenerate improved versions before finalizing them.
It is mandatory to click **Save** to retain the generated test cases. If not saved, the generated test cases will not be retained and will no longer be available. Upon saving:
* Test Cases will appear under the **Test Case Module**.
* Steps, validations, parameters, and screenshots (if generated) will be reflected accordingly.
Additionally, you can **Download** the generated test case file for reference. If the file is no longer required, you may choose to **Delete** it. Please note that deleting a file is a permanent action and cannot be undone.
# Scripts (Script-to-Test Case Conversion)
**When to Use Script-to-Test Case Conversion:**\
Use this feature when you have existing automation test scripts and want to automatically convert them into structured, execution-ready test cases within WalnutAI.
* **Supported Scripts:** Playwright (.ts, .js, .spec.ts, .spec.js)
#### **Steps to Generate:**
* **Select Scripts:** Click the **Scripts** option under the **Generate Test Cases** section.
* **Upload:** Drag and drop Playwright script files or click **Upload** to select script files from your local device.
* Click **Analyse Scripts** to allow WalnutAI to process the uploaded files.
* **AI Analysis:** WalnutAI analyses the uploaded scripts to extract step definitions, step-level actions, assertions (automatically converted into validations), and variables (converted into parameters where applicable).
* **Review & Refine:** Review the generated test cases and refine them using the **WalnutAI Chatbot** to enhance steps, validations, and scenarios if required.
* **Save:** Click **Save** to store the generated test cases in the system.
{% hint style="info" %}
**Result:** Saved **Test Cases** will appear in the **Test Case Module** reflected accordingly.
{% endhint %}
# Smart Recording
The Smart Recording section in the Intelligence Hub helps you create structured, ready-to-use test cases directly from a live application. You can either describe what you want to test in simple words, or you can simply record your actions. WalnutAI then captures those steps and automatically converts them into clear, complete test case flows.
By selecting **Smart Recording**, you can connect to an application URL and choose between [**Generator Mode**](/core-features/intelligence-hub/generate-test-cases/smart-recording/generator-mode) or [**Debug Mode**](/core-features/intelligence-hub/generate-test-cases/smart-recording/debug-mode). Based on the selected mode, WalnutAI either interacts with the application using prompts or records your manual actions while structuring them into organized test cases.
During recording, WalnutAI automatically captures:
* User actions as structured test steps
* Validations for actions performed
* Parameters where applicable
* Screenshots for each recorded step
You can further refine the recorded test flow by adding prompts, improving step clarity, or introducing additional scenarios.
It is mandatory to complete the session by clicking **Disconnect** and then **Done** to finalize the recorded test case. If the session is not completed, the generated steps will not be finalized.
{% hint style="info" %}
**Result:** Saved **Test Cases** will appear in the **Test Case Module** reflected accordingly.
{% endhint %}
# Generator Mode
Generator Mode in [Smart Recording](/core-features/intelligence-hub/generate-test-cases/smart-recording) lets you create test cases directly from your application. You just describe what you want to test in simple words, and WalnutAI does the steps for you and turns them into clear, ready to use test cases.
You can select the required platform such as [**Web**](broken://pages/xt4uvkpRPWW4txF9TrlF), [**API**](broken://pages/UiPVyRapE47khziPL2Ow), or [**Database**](broken://pages/FomfASvaxdYzOrZSXSP7), and connect to the application or endpoint. WalnutAI executes the actions based on your prompts and records them as structured test steps.
During the session, WalnutAI automatically captures:
* Structured test steps
* Validations
* Parameters (such as inputs, URLs, or credentials)
* Screenshots for each step
You can continue refining the test flow by adding prompts to expand scenarios, improve validations, or enhance step clarity.
It is **mandatory** to complete the session by clicking **Disconnect** and then **Done** to finalize the test case. You must also click **Save** to retain the generated test cases.
{% hint style="info" %}
**Result:** Saved **Test Cases** will appear in the **Test Case Module** reflected accordingly.
{% endhint %}
# Web
**When to Use Web Smart Recording:**\
Use this feature when you want to generate real-time, structured test cases by interacting with a live web application using WalnutAI.
**Supported Platform:** Web Applications
**Execution Type:** AI-driven browser interaction
**Steps to Generate:**
* **Enter Application URL:** Click the **Web** option under **Generate Test Cases → Smart Recording** and enter the web application URL.
* **Connect:** Click **Connect** to launch the AI-controlled browser session and establish a live connection.
* **Provide Prompt:** Enter a prompt describing the functionality (for example: *Login to application*, *Create a new user*, *Validate dashboard widgets*). WalnutAI performs the interactions based on the prompt.
* You don’t need to overthink or write detailed steps to get started. Just give a simple prompt describing what you want to test, and WalnutAI takes it from there. I
* If something is unclear or missing, WalnutAI doesn’t assume but it asks. Its question-back mechanism helps fill in the gaps by coming back to you with the right questions, making sure every scenario is properly covered.
* It even thinks beyond the obvious to ensure nothing important is left out.
At any point, you can jump into the chat, clarify things, tweak the flow, or refine the test case. It feels more like a conversation than a process, giving you full control while keeping the effort minimal.
* When a test case flow has already been created and multiple scenarios need to be handled without breaking it, Smart Recording allows Multiple Test Case Generation while keeping the same flow intact. This ensures all scenarios are covered smoothly, without missing anything.
* **AI Analysis & Recording:** WalnutAI interacts with the application and automatically records structured test steps, captures screenshots, detects validations, and manages page navigations.
* **Multiple Test Case Generation:** You can generate multiple test cases in the same session by providing additional prompts. Instead of capturing just one path, the given flow is automatically understood and split into multiple test cases. This ensures that different possibilities, conditions, and outcomes are covered in a simple and complete way, so scenario is missed.
* **Parameter Generation:** Input values such as usernames, passwords, form data, URLs are automatically converted into reusable parameters.
* **Enhance Coverage:** You can add more prompts to introduce negative scenarios, improve validations, or expand the workflow.
* **Finalize Session:** Click **Disconnect** and then **Done** to complete the recording session.
* **Save:** Click **Save** to store the generated test case. If not saved, the generated test case will not be retained.
{% hint style="info" %}
**Result:** Saved **Test Cases** will appear in the **Test Case Module** reflected accordingly.
{% endhint %}
# API
**When to Use API Smart Recording:**\
Use this feature when you want to generate real-time, structured API test cases by interacting with live applications using WalnutAI.
* **Supported Platform:** API
* **Execution Type:** AI-driven API interaction
**Steps to Generate:**
* **Enter Application URL:** Click the **API** option under **Generate Test Cases → Smart Recording** and enter the base application URL.
* **Connect:** Click **Connect** to start the AI-controlled session. WalnutAI establishes the connection and begins monitoring API network activity.
* **Provide Prompt:** Enter a prompt describing the API functionality (for example: *Generate login API test case*, *Validate dashboard API*, *Create user API flow*). WalnutAI triggers API calls and structures them into test steps.
* **AI Analysis & Recording:** WalnutAI captures API requests, endpoints, payloads, headers, response codes, and validations while structuring them into organized test steps.
* **Parameter Generation:** Input values such as base URLs, endpoints, credentials, headers, payload values, and expected responses are automatically converted into reusable parameters.
* **Step Optimization:** You can provide prompts to optimize the API flow. WalnutAI removes redundant API calls, retains required validations, and structures the steps into an optimized, execution-ready API test case.
* **Finalize Session:** Click **Disconnect** and then **Done** to complete the recording session.
* **Save:** Click **Save** to store the generated test case. If not saved, the generated test case will not be retained.
{% hint style="info" %}
**Result:** Saved **Test Cases** will appear in the **Test Case Module** reflected accordingly.
{% endhint %}
# Debug Mode
**Debug Mode** in **Smart Recording** allows you to generate structured test cases by manually interacting with a live web application. Instead of giving prompts, you perform the actions yourself while WalnutAI records each step automatically.
By selecting **Debug Mode**, you can connect to a **Web** application. Once connected, WalnutAI launches a browser session and starts recording your actions such as clicks, text inputs, page navigation, and form submissions.
During the session, WalnutAI automatically captures:
* Structured test steps
* Validations
* Parameters (input values)
* Screenshots for each step
You can refine the recorded test flow by editing steps, adding validations, or introducing additional scenarios.
It is **mandatory** to complete the session by clicking **Disconnect** and then **Done** to finalize the recording. You must also click **Save** to retain the generated test case.
{% hint style="info" %}
**Result:** Saved **Test Cases** will appear in the **Test Case Module** reflected accordingly.
{% endhint %}
# Web (Debug Mode)
**When to Use Web Debug Mode:**\
Use this feature when you want to generate real-time test cases by interacting with a live web application while WalnutAI records each action automatically.
* **Supported Platform:** Web Applications
* **Execution Type:** Manual browser interaction with automatic step recording
**Steps to Generate:**
* **Enter Application URL:** Click **Web** under **Generate Test Cases → Smart Recording → Debug Mode** and enter the web application URL.
* **Connect:** Click **Connect** to launch the browser session and establish a live connection. Recording starts automatically.
* These toolbar options help you control recording, capture elements, and add validations like visibility, values, and screenshots while interacting with the application.
* **Manual Interaction:** Perform actions directly in the launched browser (for example: login, create user, submit forms, validate dashboard). WalnutAI records each interaction automatically.
* **Automatic Recording:** WalnutAI captures structured test steps, screenshots for every step, user actions such as clicks and inputs, and page navigations.
* **Add Validations:** You can add validations such as verifying element visibility, page titles, or success and error messages.
* **Parameter Generation:** Input values such as usernames, passwords, form data, URLs, and expected values are automatically converted into reusable parameters.
* **Enhance Coverage:** You can add negative scenarios, improve validations, refine steps, or remove unnecessary steps during the session.
{% hint style="info" %}
You can also switch to **Generator Mode** to add more validations or negative scenarios using AI prompts.
{% endhint %}
* **Finalize Session:** Click **Disconnect** and then **Done** to complete the recording session. If the session is not completed, the recorded steps will not be finalized.
* **Save:** Click **Save** to retain the generated test case. If not saved, the recorded test case will not be retained.
{% hint style="info" %}
**Result:** Saved **Test Cases** will appear in the **Test Case Module** reflected accordingly.
{% endhint %}
# Code (Repository-to-Test Case)
**When to Use Code Repository Analysis:**\
Use this feature when you want to generate test cases by analysing code from connected repositories. WalnutAI scans the repository, understands the application logic, and helps generate structured test cases.
**Steps to Generate:**
* **Select Code Repository:** Click **Code** under **Generate Test Cases**.
* **Connect Repository:** If no repositories are connected, click **Add Repo** to navigate to the **Connect Repository** page and link your Git provider. If the project does not have an Code Repository tools connected, you will be automatically redirected to setup the [Code Repository platform integration with WalnutAI ](/getting-started/projects/create-a-new-project/external-data-and-connections)so that you can connect with your code repository.
* **Choose Repository:** Select one or more connected repositories and click **Add Selected Repositories**.
* **Discover Modules:** WalnutAI scans the repository and identifies logical modules based on the repository structure and code patterns.
* **Select Modules:** Choose the relevant modules you want to analyze and click **Continue to Chat**.
* **Generate Test Cases:** Use the **WalnutAI Chatbot** to generate test cases by providing prompts such as *generate functional test cases*, *create API test cases*, or *add negative scenarios*.
* **Review & Refine:** You can modify generated steps, add validations, improve scenarios, or refine the test cases using the chatbot.
* **Save:** Click **Save** to retain the generated test cases. If not saved, the generated test cases will not be retained.
**Download & Repository Management:** Generated test cases can be downloaded for reference, and repositories can be managed from the **Connect Repository** page.\
Analyse connected code repositories to generate structured, execution-ready test cases.
{% hint style="info" %}
**Result:** Saved **Test Cases** will appear in the **Test Case Module** reflected accordingly.
{% endhint %}
# Gap Analysis
The **Gap Analysis module** serves as the alignment engine of the WalnutAI platform. It continuously evaluates how well business requirements (stories) align with the implemented code, ensuring that development accurately reflects product intent while maintaining overall code quality.
#### How is Gap Analysis helpful?
In complex and evolving projects, it’s important to have clear visibility into how the system is built, tested, documented, and secured. Gap Analysis helps identifying architectural issues, documentation gaps, unit test coverage gaps, and security risks early, helping teams maintain quality and control across the SDLC.
This helps you quickly understand what needs attention and where to focus first, making it easier to prioritize fixes and improve overall code quality with clarity and confidence.
The following are the Insights provided during Gap Analysis:
#### Story Coverage Analysis
Analyse whether each documented requirement has been fully and correctly implemented in the codebase.
#### Missing Story Detection
Identify implemented functionality that does not have an associated requirement, helping prevent scope creep and undocumented changes.
#### Implementation Health Metrics
View coverage percentages, gap counts, and alignment scores to quickly assess project health at a glance, along with indicators of code quality, testing completeness, and technical risk.
#### Code Quality & Documentation Review
Evaluate engineering standards, technical debt indicators, documentation completeness, architectural structure, unit test coverage, and security posture to ensure a robust and maintainable codebase.
#### Traceability & Governance
Maintain a clear, auditable link between business intent, development output, and quality validation, ensuring transparency across requirements, implementation, and engineering quality.
#### AI-Powered Risk Detection
Leverage WalnutAI to intelligently analyse requirements and code, identifying functional gaps, architectural weaknesses, security vulnerabilities, and testing gaps beyond simple keyword matching.
Gap Analysis transforms alignment from a manual review process into a continuous, end-to-end intelligence layer. It enables teams to monitor and improve every phase of development from requirement coverage and implementation accuracy to architecture quality, testing reliability, documentation completeness, and security ensuring high-quality, scalable, and reliable software delivery.
# Phase 1: Missing Code Detection
**Phase 1:** Missing Code Detection validates whether documented requirements are implemented in the connected code repository. In this phase, User Stories act as the baseline, and WalnutAI verifies whether corresponding functionality exists in the selected code branches.
* Before starting the analysis:
* The project must contain **User Stories** in the Action Items.
* Ensure all required stories are created and available, these stories will be used as the reference for comparison against the codebase.
* To start the analysis:
* Click **Start Analysis**.
* Select one or more **connected repositories** (repositories that were linked during project creation).
* Click "**Start Analysing"** to begin evaluation and start Analysing.
* During analysis:
* WalnutAI compares each user story with the selected repository branches.
* It checks whether the requirement is fully implemented.
* It detects partially implemented functionality.
* It identifies requirements that are not implemented at all.
* After the analysis completes, the **Analysis Summary** section displays:
* **Stories Analysed** – Total number of user stories evaluated.
* **Gaps Found** – Total number of gaps identified.
* **Coverage %** – Overall implementation coverage based on analysis.
* A breakdown of **Missing**, **Incomplete**, and **Outdated** counts.
* When a user clicks on a specific user story, the **AI Recommendations** panel displays suggestions such as:
* Implementation suggestions
* Displays estimated effort (if available).
* Highlights missing elements.
* Shows related code references with match percentage.
* Recommends an approach to close the identified gap.
* The **Confidence Score** indicates how strongly the implementation aligns with the requirement based on WalnutAI’s semantic comparison.
* Click **Run New Analysis** to re-evaluate the selected user stories against the latest code changes and update the analysis results accordingly
Phase 1 ensures every user story is validated against the codebase, clearly identifies missing or incomplete implementations, maintains requirement-to-code traceability, and enables teams to proactively resolve gaps before release.
# Phase 2: Missing Story Detection
**Phase 2:** Missing Story Detection identifies functionality that exists in the codebase but is not documented as user stories. WalnutAI also validates existing stories to assess coverage and provides AI-driven suggestions for improving and updating them. In this phase, the code acts as the baseline, and WalnutAI detects undocumented or incomplete requirement coverage.
* **Before starting the analysis:**
* The project must be connected to one or more repositories.
* Ensure the repositories were properly integrated during project creation.
* The codebase from the selected repositories will be used as the reference for comparison against existing user stories.
* **To start the analysis:**
* Click **Start Analysis**
* Select one or more connected repositories.
* Click **Start Analysing** to begin evaluation.
* **During analysis:**
* WalnutAI scans the selected repository and branch.
* It compares implemented code with documented user stories.
* It identifies functionality implemented in code but not documented as a story.
* It detects stories that require corrections or acceptance criteria improvements.
* It enhances acceptance criteria to fully reflect implemented behaviour.
* It generates new user story suggestions for uncovered features.
* **After the analysis completes, the dashboard displays:**
* **Stories Analysed** – Total number of stories reviewed.
* **Corrections Needed** – Stories requiring refinement.
* **Missing Stories** – Undocumented features detected from code.
* **High Priority** – Critical missing or impacted stories.
* **In the Analysis Results section:**
* Separate tabs for **Corrected Stories** and **Missing Stories** with respective counts.
* **For Corrected Stories:**
* Click on Option to **Select All** or select individual stories and directly **Apply Correction** using the **Apply Correction** action.
* Clear selection option to reset selections.
* Click on Story for Side-by-side comparison of **Original** and **Corrected** versions.
* Updated Title, Description, and Acceptance Criteria suggested by Walnut AI.
* Highlighted improvements in acceptance criteria coverage.
* Confidence percentage indicating alignment strength.
* **AI Reasoning** explaining why corrections are recommended.
* **For Missing Stories:**
* Click on Option to **Select All** or select individual stories and directly create user stories using the **Create Story** action.
* Clear selection option to reset selections.
* Suggested story title derived from code behaviour.
* Priority level (e.g., High).
* The **Confidence Score** indicates how strongly the detected functionality aligns with the suggested or corrected user story based on Walnut AI’s semantic and structural analysis.
* **Functionality Description** generated from implementation.
* **Suggested Acceptance Criteria** based on detected logic.
* **Related Code Files** showing impacted source files.
* Click **Run New Analysis** to scan the updated codebase and user stories again, ensuring newly implemented features and recent changes are reflected in the analysis results
Phase 2 ensures implemented features are fully documented, improves requirement and acceptance criteria quality, maintains code-to-requirement traceability, and keeps documentation aligned with actual system behaviour while preventing undocumented development.
# Phase 3: Code Quality & Documentation
**Phase 3: Code Quality & Documentation** analyses the technical health of the codebase and the code quality to identify architectural issues, documentation gaps, unit test coverage gaps, security vulnerabilities, and overall engineering quality.
This analysis helps identify gaps early, as structural code issues can pose risks at any stage, not just over the long term.\
In this phase, the codebase acts as the baseline, and WalnutAI evaluates technical debt, maintainability, and best practice compliance.
* **Before starting the analysis:**
* The project must be connected to one or more repositories.
* Ensure the repositories were properly integrated during project creation.
* The selected repository and branch will be used for technical quality evaluation.
* **To start the analysis:**
* Click **Run Analysis**
* Select the connected repository.
* Click **Start Analysing** to begin evaluation.
**During analysis:**
* WalnutAI scans the entire repository structure and evaluates the code across multiple engineering dimensions.
* It detects architectural weaknesses and design issues while also identifying missing or incomplete documentation.
* At the same time, it analyses unit test coverage to find critical path gaps and evaluates performance-related concerns.
* The system also detects security vulnerabilities and risk patterns, categorizes all identified issues based on severity and impact, and generates AI-powered suggestions to improve the overall code quality.
**After the analysis completes, WalnutAI displays the complete insights:**
* Quality & Additional Metrics
* Architectural Analysis
* Documentation Gaps
* Unit Tests Gaps
* Security Gaps
* Compliance Gaps
* **Quality Metrics & Additional Metrics:**
* It assess the system’s overall quality by evaluating documentation, unit test coverage, API documentation, architecture strength, security effectiveness, and performance efficiency.
WalnutAI provides an initial overview of key technical gaps across the codebase, including architectural issues, documentation gaps, unit test coverage gaps, and security risks, helping users quickly understand and prioritize areas that need attention.
**Architecture Analysis:**
* The system identifies large or complex functions, detects multiple responsibilities within a single module, highlights improper dependency management, flags structural design issues.
* WalnutAI also provides impact explanations along with AI-driven refactoring suggestions, displays the severity level and affected files, and allows users to select issues and create tasks accordingly.
* Click on “**Create Task**” after selecting either individual items or using the “Select All” option to create tasks.
* After clicking on “Create Task”, you can assign the task either to a user (using bulk or individual assignment) or to a [Cloud Agent](/development-and-infrastructure/cloud-agent), which can automatically handle the task without human intervention.
**Documentation Gaps:**
* The system identifies incomplete or missing explanations in functions and configurations, highlights areas with low documentation coverage percentage, suggests clearer and more comprehensive documentation improvements, and enables users to select identified gaps and create tasks to address them efficiently.
* Click on “**Create Task**” after selecting either individual items or using the “Select All” option to create tasks.
* After clicking on “Create Task”, you can assign the task either to a user (using bulk or individual assignment) or to a [Cloud Agent](/development-and-infrastructure/cloud-agent), which can automatically handle the task without human intervention.
**Unit Test Coverage Gaps:**
* The system identifies missing unit tests for critical and high-risk code paths, detects the absence of edge case and boundary condition testing, highlights the need for additional integration tests, provides coverage percentage at a file level for better visibility, suggests relevant and comprehensive test scenarios, and enables users to select identified gaps and create tasks to systematically improve overall test coverage and quality.
* Click on “**Create Task**” after selecting either individual items or using the “Select All” option to create tasks.
* After clicking on “Create Task”, you can assign the task either to a user (using bulk or individual assignment) or to a [Cloud Agent](/development-and-infrastructure/cloud-agent), which can automatically handle the task without human intervention.
**Security Gaps:**
* The system detects potential security vulnerabilities such as injection risks, unsafe configurations, and XSS issues, maps them to appropriate severity levels and recognized security standards like CWE, identifies the impacted source files, provides AI-driven mitigation suggestions, and enables users to select these vulnerabilities and create tasks to address them effectively.
* Click on “**Create Task**” after selecting either individual items or using the “**Select All**” option to create tasks.
* After clicking on “Create Task”, you can assign the task either to a user (using bulk or individual assignment) or to a [Cloud Agent](/development-and-infrastructure/cloud-agent), which can automatically handle the task without human intervention.
**Compliance Gaps:**
* WalnutAI helps you evaluate your codebase against industry-standard compliance frameworks, including **HIPAA Security Rule**, **GDPR**, **FDA 21 CFR Part 11**, and **HITRUST CSF**. Select the required framework from the **Framework** dropdown to view compliance findings specific to that standard.
* The analysis categorizes each control as **Compliant**, **Non-Compliant**, **Partial**, or **Not Determinable**, giving you a clear overview of your current compliance posture. For every identified gap, WalnutAI provides the control name and ID, a confidence score, the affected files or code locations, related compliance mappings, and AI-powered recommendations explaining what needs to be implemented or remediated to satisfy the selected compliance requirement.
Users can:
* Navigate between Architecture, Documentation, Unit Tests, Security and Compliance tabs.
* Select All or individual issues and create tasks directly from identified issues.
* The **Confidence and scoring system** reflects how well the codebase aligns with engineering best practices and maintainability standards.
* click **Run New Analysis** to re-scan the codebase for quality, security, and performance issues, ensuring the latest code changes are reflected in the analysis results.
Phase 3 ensures early detection of technical debt, maintains engineering quality standards, improves documentation and test coverage, mitigates security risks, and strengthens long-term code maintainability across the project.
# WalnutAI Coder
The **WalnutAI Coder** is an extension that integrates directly into your IDE, setting up an AI-powered development environment that enables users to efficiently create, edit, and manage application code within a structured workspace. It converts high-level requirements into technical solutions, making it easier to build and maintain applications.
#### What can WalnutAI Extension do?
**AI-Assisted Coding**\
Simply describe what you need in plain language, and WalnutAI Coder helps you generate components, APIs, and business logic. It cuts down repetitive work so you can focus more on solving real problems and less on boilerplate code.
**Works with Existing Applications & New Development**\
Whether you’re starting a brand-new project or working on an existing codebase, WalnutAI adapts seamlessly. It understands your current application structure, helps you extend features, refactor code, or even modernize legacy systems-while also being equally effective in building applications from the ground up.
**Deep Project Understanding**\
When you open a repository, the agent scans your folders, frameworks, dependencies, and coding patterns to provide suggestions that actually fit your project -not generic answers.
**Structured & Guided Workflow**\
From understanding requirements to planning architecture and finally implementing code, WalnutAI encourages a clear, step-by-step development process. This keeps your projects organized and reduces chaos as they grow.
**Interactive & Thoughtful Assistance**\
Instead of jumping straight into code, WalnutAI asks follow-up questions when something isn’t clear. This ensures the output aligns closely with what you actually want, saving time on rework.
**Safe & Controlled Actions**\
WalnutAI always keeps you informed. Before making significant changes-like running terminal commands, installing packages, or modifying key files-it asks for your approval, so nothing happens without your consent.
**Key Benefits of Using WalnutAI Code Editor**
* **Structured Automation:** Transitions seamlessly from planning to implementation without losing project context.
* **Safety & Transparency:** Every major change is gated by user approval, preventing unintended modifications.
* **End-to-End Reliability:** From the first line of code to automated test healing, the agent ensures the feature is built, tested, and maintained.
# WalnutAI Installation
Follow these steps to download and install the WalnutAI extension to enable seamless integration within your development environment:
* Open **Visual Studio**.
* Click on the **Extensions** icon located in the left sidebar of Visual Studio.
* In the search bar of the Extensions dialog, type **WalnutAI.**
* Find the WalnutAI extension from the search results and click the **Install** button associated with the extension.
* Once installed, WalnutAI will be available in your Visual Studio environment for use.
* Log in with your WalnutAI account.
* Select a project and start prompting.
# Working with New Applications and Existing Repositories
The WalnutAI Agent adapts its workflow based on whether you are building a new application or working with an existing repository. The agent remains the default interface, dynamically transitioning between modes as required by the task.
**Building a New Application**
To start a project from scratch:
* Create a folder on your local machine and open it in VS Code.
* Activate the WalnutAI extension and select the project.
* Provide the Agent with your high-level requirement (for example, “Build a Task Management API”). Once submitted, the Agent proceeds through the following structured workflow:
* **Analyze:** The Agent reviews your request and automatically enters [**Plan Mode**](#user-content-fn-1)[^1] to create a structured technical roadmap.
* **Clarify:** If any information is unclear or incomplete, WalnutAI triggers a Q\&A mechanism to gather the necessary details, ensuring it avoids assumptions and does not hallucinate.
* **Implement:** After you approve the proposed plan, the Agent begins implementation, requesting explicit permission before running terminal commands or making significant changes.
**Working with an Existing Repository**
To enhance or maintain an existing project:
* Clone the repository manually using VS Code.
* Open the project folder to allow the Agent to scan dependencies, frameworks, and architectural patterns.
* Start prompting for specific use cases like bug fixes, refactoring, or documentation.
[^1]: Converts high-level ideas into a clear, step-by-step technical plan before any code is written.
# Dev & QA Workflow Overview
WalnutAI unifies development and quality assurance into a single, seamless workflow. In Dev Mode, it guides you through planning, understanding, and building features-whether for new projects or existing applications. In QA Mode, it ensures reliability through test design, automated test generation, and continuous stability. The agent serves as the default interface, intelligently switching between modes based on the task to deliver a smooth, end-to-end development experience.
#### Dev Mode
In Dev Mode, the agent assists with development through the following modes:
* **Plan Mode**: Acts as the architect, transforming high-level prompts into a structured, step-by-step technical roadmap before any code is written.
* **Ask Mode**: Enables users to clarify requirements, gather insights, and receive guidance throughout the development process.
Additionally, the **Tasks** section in Dev Mode provides visibility into all tasks assigned to the user. By selecting a task, users can directly begin working on and resolving it.
#### QA Mode
In QA Mode, the agent supports testing and quality assurance through the following modes:
* **Test Planner Mode**: Acts as the strategist, identifying critical paths that require testing and defining the overall validation strategy.
* **Test Generator Mode**: Functions as the QA engineer, automatically generating executable unit, integration, or end-to-end tests.
* **Test Healer Mode**: Acts as the maintainer, executing tests, diagnosing failures, and automatically updating code or test logic to restore stability.
* **Repository & Custom Method Workflow:** Within QA Mode, users can manage repositories and create custom methods. Before proceeding, ensure that the selected project is properly configured with the appropriate repository.
* **Open Repo**: Clicking **Open Repo** allows you to select a local folder, where the repository will be cloned.
* **Initialize:** Sets up the repository and creates a sample method.
* **Custom Method Creation**: Selecting “Custom Method” initiates a series of structured questions to capture the method’s purpose, required actions, and inputs. Based on these inputs, the system automatically generates the requested method.
* **Sync**: The created method is synced to WalnutAI. Once synchronized, it can be accessed via Admin Settings under Action Settings or within test steps using “/ → Actions.”
* **Version Control**:
* **Push**: Upload the created method to the repository.
* **Pull**: Fetch the latest updates from the repository.
* **Debug Mode**:
* Activate Debug Mode to test and troubleshoot custom methods.
* To debug, create a test case, link the custom method, and execute the test case to validate functionality.
**Human-in-the-Loop Workflow**
To ensure you maintain total control, the agent operates within a strict safety and collaboration framework:
* **Interactive Q\&A Mechanism:** If a prompt is ambiguous (e.g., "Add login"), the Agent pauses to ask targeted questions about authentication methods or database preferences rather than making assumptions.
* **Approval Framework**: The Agent must receive your explicit permission before performing impactful actions, including:
* Running terminal commands.
* Deleting or restructuring project files.
* Applying large-scale refactors or database migrations.
# Cloud Agent
The **Cloud Agent** feature enables you to provision remote machines and deploy AI-powered agents that automatically execute development tasks in a secure cloud environment. After configuring a compute instance, the system prepares the remote machine by installing the required dependencies, configuring the environment, and deploying the agent.
Once deployed, Cloud Agents remain in an idle state until tasks are assigned. Tasks created from any module in WalnutAI are automatically queued and executed by the assigned Cloud Agent. During execution, the agent launches a browser-based development environment, analyzes the codebase, applies fixes, and generates pull requests with the required code changes. If review comments are added to the pull request, the agent can process the feedback and apply the necessary updates, enabling an efficient, end-to-end automated development workflow.
**Why Use Cloud Agents?**
* Automates the execution of development tasks on remotely provisioned machines.
* Eliminates the need for manual environment setup and task execution.
* Automatically applies code changes and generates pull requests.
* Helps resolve pull request review comments by applying the required fixes.
* Reduces manual effort, accelerates development, and improves overall productivity.
# Cloud Machine Setup and Agent Deployment
Before an agent can run, you must prepare the remote Machine that will host it.
Steps to create a remote Machine:
* Navigate to Admin Settings and click 'Compute Configuration'
* Click 'Add Compute'.
* Fill in the details:
* **Name & Type:** Fill in the Compute Name and select the type.
* **Connection:** Enter the Host / IP (internet address) and the SSH Port (usually 22).
* **Authentication:** Provide the Username and Password/SSH Key so the system can access the server.
* **Define the Environment:** Enter the Docker Image path (e.g., `walnut-cloud-agent:latest`). If the image is private, provide the Registry Server, Username, and PAT.
* **Assign a Subdomain:** Assign a unique URL (e.g., `agent2.walnut.ai`) for browser-based access. Ensure the domain's A record points to your VM IP.
* **Validate & Provision:**
* Click Test to confirm the credentials and network settings are correct.
* Click Update VM: This autonomously installs Docker, configures, performs DNS mapping, and pulls the latest Code Editor Docker images.
**Steps to Create a Cloud Agent**
Once the machine status is Active and the environment is fully provisioned, you can deploy the agent.
* Go to the Agents and click 'New Agent'.
* Provide a name for the agent and select the Compute Instance you just created from the dropdown menu.
* Click 'Create'.
**What Happens Next?**
Once created, your agent will sit in an Idle state. It consumes minimal resources while waiting for a task to be assigned. As soon as a task enters its queue, it will wake up and begin execution.
# Task Assignment, Execution, and PR Management
**Task Assignment Workflow:** Tasks are created directly from the Gap Analysis module, allowing for flexible distribution across your agents.
* **Creation:** Select the identified issues in Gap Analysis and click 'Create Task'.
* **Assignment Types:**
* Bulk Assign: Send all selected issues to a single agent for consolidated processing.
* Individual Assign: Distribute specific issues to different agents based on their workload or machine capacity.
* **Execution:** Once you click 'Create Task', the system wakes up the assigned agent. The agent pulls tasks from its queue, executes them sequentially, and returns to an Idle state once the queue is empty.
**Live Code Execution Environment:** The system launches a real-time, browser-based environment on the cloud machine that functions like a high-performance IDE.
* Autonomous Progress: The editor automatically loads and begins the first task in the queue. You can watch the agent analyze files and apply code fixes in real time.
* Streamlined Logic: To maximize efficiency, this environment skips manual approval gates the system automatically approves and executes actions to maintain momentum.
**Pull Requests and Comment Resolution:** After completing a task, the agent automatically generates the required code changes and creates a Pull Request (PR) in the repository.
* For example, in Azure Repos, the Pull Request may be raised by the WalnutAI Cloud Agent, including the necessary code modifications and fixes identified during task execution.
* Users can add comments to the pull request. If feedback is provided, users can click Fix PR Comments. This allows the agent to review the comments and apply the necessary fixes to resolve the feedback.
# Test Management
Create, organize, and manage your test cases and test suites in a structured and centralized workspace. This section helps you define clear test scenarios, map them to features and epics, and maintain visibility into key details such as status, priority, and execution results. It enables consistent tracking and better organization of your testing efforts across the project lifecycle.
Within the **Test Management**, all test cases are displayed in a centralized table view. Each row represents an individual test case and includes key attributes such as Test Case ID, Test Case Name, Feature, Epic, Status, Priority, and Execution Status, providing clear visibility into validation progress across the project.
You can also perform bulk actions like **importing** and **exporting** test cases, making it easier to onboard large datasets or share test assets across teams. With filtering, sorting, and quick access to actions, this page is designed to simplify test management. You can **Delete** test cases when they are no longer required, noting that deletion is a **permanent action** and cannot be undone.
WalnutAI also supports the creation and execution of **Test Suites**, enabling users to group multiple test cases together and execute them collectively for feature-level or regression-level validation.
Users can create test cases manually or generate them using AI from user stories, documents, or integrated sources. Each test case supports detailed step configuration, dataset-driven execution, nested test case reuse, and both manual and automated execution modes. With built-in AI assistance and execution tracking, test cases in WalnutAI provide a structured and traceable framework for comprehensive application validation.
# Test Cases
A Test Case in WalnutAI is a structured validation unit designed to verify that an application behaves as expected. It defines a clear sequence of steps, associated objects, expected outcomes, and supporting test data to ensure functional accuracy and requirement compliance. This structured approach enables consistency, traceability, and reliable validation across the application.
In this module, you will learn how to create a test case, manage its test data effectively, build nested test cases, implement conditional workflows (such as If/Else and loops), execute test cases, and leverage AI Healing to automatically detect and resolve UI or object-level changes during execution.
# Test Case Creation
**Steps to Create a New Test Case**
* Select '**Create New Test Case.**
* Open **Test Case Information** and provide all necessary details, making sure all required fields are completed before moving forward.
* **Test Case ID:** A unique, system-generated identifier used for tracking and referencing the test case across the project.
* **Title:** Enter a concise name that clearly describes the functionality being validated; this is a mandatory field.
* **Description:** Provide a detailed overview explaining the purpose of the test and its coverage.
* **Objective:** Define the specific goal of the test and the exact behaviour you are verifying.
* **Epic, Feature, & User Story:** Select these from the dropdowns to map the test case to its originating requirement, ensuring 100% traceability.
* **Test Category & Type:** Categorize the test (e.g., Manual or Automation) and its functional area, such as Regression or UI.
* **Priority:** Rank the importance of the test (Low, Medium, High, or Critical) to help the team prioritize execution.
* **Status:** Track the current state of the test case, such as Draft, Reviewed, or Approved.
* **Preconditions:** List any setup requirements as pre-requisites that must be met before the test begins, such as "User must be logged in".
* **Expected Outcome:** State the successful result you expect to see once all steps are completed.
#### Defining and Managing Steps
* Use the **Add Step** option to add test steps. Define the step description and specify the expected result for each step.
* Configure relevant **objects and parameters** wherever applicable.
* **Global Variables:** Type **`$(`** to access the dropdown for static, project-wide values.
* **Runtime Variables:** Type **`$[`** to access the dropdown for dynamic values generated during execution.
* **Local Variables:** Type **`${`** to open the dropdown for data specific to the current test case.
* **Actions:** Alternatively, type **`/`** to open a comprehensive menu that includes objects, test case types, variables, and reusable actions.
* Click **Save** to save the test case.
* After saving, set up the required **test data.**
**WalnutAI provides multiple ways to generate test cases based on your workflow needs.**
* **From the** [**Intelligence Hub**](/core-features/intelligence-hub)**:** You can choose between two approaches:
* **Requirement-Driven Path:** Generate a User Story first, then **Generate Test Cases** to maintain full traceability.
* **Direct Generation Path:** Skip story creation and directly generate test cases from source documents or repositories for faster validation.
* **From the** [**Action Items Module**](/overview-and-tracking/action-item/ai-driven-requirement-enhancement-and-test-generation)**:** If requirements are already saved:
* Open an existing User Story and use the **AI Generate** option.
* A test case will be automatically created and linked to that story.
* **From an Existing Test Case:**
* Open any existing test case, select the test steps and click on '**Save as New Test Case'.** This allows you to quickly duplicate and modify existing test cases without starting from scratch.
# Manage Test Data of a Test Case
**Test Data** refers to the set of input values and parameters used to execute a test case and validate system behaviour. Proper test data ensures accurate, consistent, and repeatable test execution.
Test Data Management in WalnutAI consists of [**Test Data**](#user-content-fn-1)[^1] and [**Nested Test Data**.](#user-content-fn-2)[^2]
* The Test Data section is specific to an individual test case, allowing you to define the exact values as per the test case which will be used during execution.
* To add a dataset in a test case open the test case > Test Data and click '**Add Dataset'** and enter parameter values (such as URL, Email, or Password). All fields are editable and can be customized based on your test requirements.
* Use the '**Import'** option to upload external datasets if they are already available.
* Click '**Export'** to download the existing datasets for external use.
* After adding or updating data, click '**Save All'** to ensure the datasets are stored and ready for execution.
{% hint style="info" %}
Test cases created using **Smart Recording from the Intelligence Hub** will have parameters automatically identified and mapped.
{% endhint %}
* **Nested Test Data** section applies to nested test cases (reusable test cases executed within other test cases).
* **Left Panel:** Displays the nested test case structure (branches).
* **Right Panel:** Shows parameter values and datasets for the selected branch.
{% hint style="info" %}
If multiple datasets exist, select the required ones using the checkbox to make it as Default which will be used for execution; otherwise, the system defaults to the first dataset. When multiple datasets are selected, the platform performs **Iterative Execution**, running the test once per selected dataset.
{% endhint %}
[^1]: Test Data is the input you give to a test case to check if the system works correctly.
[^2]: Nested Test Data is the input used for a nested (reusable) test case that runs inside another test case.
# Manage Test Step
Each test step provides a range of actions that enable you to control and customize the execution flow with precision.
Within the Test Case Editor, you have full control over step behavior, supported by smart shortcuts for faster and more efficient execution:
**Smart Shortcuts**
* **Global Variables**: Type `$(` to access a dropdown of static, project-wide values.
* **Runtime Variables**: Type `$[` to access dynamic values generated during execution.
* **Local Variables**: Type `${` to open a dropdown for data specific to the current test case.
* **Actions Menu**: Type `/` to open a comprehensive menu that includes objects, test case types, variables, and reusable actions.
**Step Actions**
* **Object Management**: Add or modify the object associated with a specific step.
* **Create New Step**: Insert a new test step at any point in the sequence. Define the step description and expected result to refine validation logic.
* **Advanced Logic**: Apply conditional logic such as if/else statements, loops (e.g., while), or invoke a nested test case.
* **Skip Step**: Skip a specific step during execution without removing it from the test case.
* **Screenshots**: Capture and view screenshots for individual steps as visual evidence.
* **Delete Step**: Remove a test step that is no longer required.
* **Export**: Export the complete test case as a Playwright script for external automation use.
{% hint style="info" %}
After making any changes, you must click Save before navigating away to ensure your updates are not lost.
{% endhint %}
# Nested Test Case
**Nested Test Cases** are reusable test cases that are called and executed within another parent test case as part of its workflow.
They allow you to embed a predefined set of steps (such as login, setup, or validation flows) that are used frquently inside a larger test scenario, enabling modular, reusable, and maintainable test design.
* **Nested Test Case:** To add a nested test case, hover over the desired test step and click the branching icon.
* Choose **'Nested Test Case'** from the available options.
* Select the required test case to call, then click **'Confirm Selection'** to proceed.
* The **Branches View** is also available within the **Nested Test Data** section to view and manage the associated branches and their datasets.
# Add Control Flow (Conditional Statements)
Adding a Control Flow (Logical Conditions) allows you to introduce conditional logic inside a test case to control execution based on defined conditions. It helps create dynamic, intelligent, and flexible test scenarios without writing manual code.
Control Flow is useful when certain steps should execute only under specific conditions, such as validating error messages, handling optional flows, retrying actions, or managing dynamic application behaviour.
**To add a control flow:**
* Hover over the desired test step and click the branching icon.
* Choose one of the available options:
* [**If / Else**](/test-and-quality-management/test-management/add-control-flow-conditional-statements/if-else)
* [**While Loop** ](/test-and-quality-management/test-management/add-control-flow-conditional-statements/while-loop)
# If / Else
If / Else enables a test case to follow different execution paths depending on whether a specified condition evaluates to true or false, allowing dynamic and logic-based test execution.
If certain steps need to be executed only when a condition is true (for example, login is successful), add them under the **If** section.\
If the condition is false, alternative steps can be added under the **Else** section.
* Click **"If / Else"** to add a conditional block in the test case.
* **Set Condition for If -**Choose how to set the condition:
* **Element**
* **Parameter**
* **Element -**Choose **"Element"** when the condition depends on an object (UI element, text, etc.) on the screen.
* From the dropdown, select the required option:
* Conditions (is visible, is not visible)
* Actions
* Interactions(click, type, focus..)
* **Example:**\
To check if the **"Login Successful"** message is visible after clicking the login button:
* If the message is visible → condition is true
* If not → condition is false
* Select the required "**Object"** (stored using XPath / Playwright).
* Click "**Save"** to apply the condition.
* **Parameter** - Choose **"Parameter"** when the condition depends on a value.
* From the **1st dropdown**, choose an existing parameter OR Click "**Create"** to add a new parameter:
* Enter Name (e.g., login\_status)
* Enter Value (e.g., success)
* Select Type (String, Number, etc.)
* Click **Create**
* From the **2nd dropdown**, select the comparison type\
(equals, not equals, greater than, less than, contains, etc.)
* Enter the comparison value (e.g., success)
* **Example:**\
To check if the login status is successful:
* If login\_status = success → condition is true
* If login\_status ≠ success → condition is false
* Click "**Save"** to apply the condition.
* **If (True Condition Steps)-**Add the required steps under **If**.
* These steps execute only when the condition is true.
* **Else**
* Add the required steps inside the "**Else"** section.
* These steps execute only when the **If condition evaluates to false**.
* **Example:**\
If login is not successful:
* Show error message
* Retry login
* Capture screenshot
* If needed, update or modify the description
* Click **"Save"** after changing description
* **Else (False Condition Steps)-**Add the required steps inside the **Else** section.
* These steps execute only when the condition evaluates to false.
* **End If**
* **End If** marks the end of the If / Else condition.
* It closes the conditional block and completes the flow.
* If needed, update or modify the description
* Click **"Save"** after changing description
* **Example Flow**
* If login is successful:
* Perform dashboard actions
* Else:
* Show error and stop execution
* After **End If**:
* Continue with remaining test steps
# While Loop
While Loop enables a test case to repeatedly execute a set of steps as long as a specified condition evaluates to true, allowing controlled and condition-based iteration within the test flow.
If certain steps need to be repeated until a condition becomes false (for example, retry login until successful), add them under the **While** section.
* Click **"While Loop"** to add a loop block in the test case.
* **Set Condition for While - Choose how to set the condition:**
* **Element**
* **Parameter**
* **Element** - Choose **"Element"** when the condition depends on an object (UI element, text, etc.) on the screen.
* From the dropdown, select the required option:
* Conditions (is visible, is not visible)
* Actions
* Interactions (click, type, focus, etc.)
* Select the required "**Object"** (stored using XPath / Playwright).
* Set **Max iterations** (default: 100).
* **Example:**\
To retry login until the success message appears:
* While **"Login Successful"** message is not visible → condition is true
* If the message becomes visible → condition becomes false
* The system will keep retrying login until the message appears or max iterations are reached
* Click "**Save"** to apply the condition.
* **Parameter** - Choose **"Parameter"** when the condition depends on a value.
* From the **1st dropdown**, choose an existing parameter OR Click "**Create** to add a new parameter" :
* Enter **Name** (e.g.,retry\_count)
* Enter **Value** (e.g., 0)
* Select **Type** (String, Number, etc.)
* Click **Create**
* From the **2nd dropdown**, select the comparison type:
* equals
* not equals
* greater than
* less than
* contains
* Enter the comparison value (e.g., 3).
* Set **Max iterations**.
* **Example:**\
To retry login for limited attempts:
* While retry\_count < 3 → condition is true
* If retry\_count ≥ 3 → condition becomes false
* The system will retry the steps until the condition becomes false or max iterations are reached
* Click "**Save"** to apply the condition.
* **While (Loop Steps)**
* Add the required steps under **While**.
* These steps execute repeatedly as long as the condition is true.
* End While
* End While marks the end of the While loop.
* It closes the loop block and completes the flow.
* The loop stops when:
* Condition becomes false
* OR max iterations limit is reached
* If needed, update or modify the description
* Click **"Save"** after changing description
* **Example Flow**
* While login is not successful:
* Enter username and password
* Click login
* Wait for response
* After End While:
* If login is successful → go to dashboard
* Else → show error and stop execution
* Continue with remaining test steps
# Creating Test Cases in WalnutAI
WalnutAI supports multiple platforms of test cases to validate different layers of your application. Each test case type ensures complete functional coverage, from frontend user interactions to backend services and database validation.
* **Web Test Cases**\
Designed to validate frontend application behaviour and user journeys.\
They verify UI elements, form validations, navigation flows, authentication processes, and complete end-to-end workflows.
* **API Test Cases**\
Designed to validate backend services and system integrations.\
They allow configuration of HTTP methods (GET, POST, PUT, DELETE, PATCH), headers, authentication, parameters, and request payloads.\
API test cases verify response status codes, add assertions, headers, and response data, and support variable extraction for use in subsequent steps.
* **Database Test Cases**\
Designed to validate data integrity and backend storage operations.\
They connect to supported databases, execute SQL queries, and validate returned results.\
Database test cases ensure accurate data validation after UI or API operations and support assertions and parameterized execution.
* **Hybrid Test Cases (End-to-End Validation)**\
WalnutAI also supports combining Web, API, and Database steps within a single test case.\
This allows full end-to-end validation for example, performing a UI action, validating the API response, and verifying database changes in one structured workflow.\
This unified approach ensures complete traceability and comprehensive application validation across all layers.
By supporting individual and combined test case platforms within a single framework, WalnutAI enables structured, end-to-end testing with improved quality, better visibility, and reduced risk throughout the application.
# How to create Web test case
A Web Test Case is a structured validation scenario designed to test the functionality and behavior of a web application in a browser. It simulates real user interactions such as entering data, clicking buttons, and navigating pages ensure UI elements and workflows function as intended.
#### **Steps to Create a Web Test Case**
* Click on [**Create New Test Case**](/test-and-quality-management/test-management/test-cases/test-case-creation) button to start a new validation scenario.
* Click "**Add Step"**, then type **“/”** inside the step field. From the dropdown menu, choose **Test Case Type** and select **Web**. This allows you to build structured web validation steps without writing manual code.
* **Add Step Description & Use Variables**:
* Enter the test step description in simple English.
* **To reuse an existing Variables**: type `$(` for Global variables, `${` for Local variables, or `$[` for Runtime variables to open the dropdown and select the required value.
* **To create a new Variables**: Refer to the **Create New Variables** section for guidance.
4. Once all steps are defined, click **Save** to store your test case in the dashboard.
5. Run the created web test case using either **Manual** or **Automation (AI)** mode.
To understand the details of running your tests and how the system handles changes, refer to the documentation on [Execution & AI Healing](/test-and-quality-management/test-management/execution-and-ai-healing).
# How to create API test case
An API Test Case is a structured validation scenario designed to test the functionality and behaviour of backend services. It validates API endpoints by sending requests and verifying responses such as status codes, headers, and response data to ensure the service works as intended.
#### **Steps to Create a API Test Case**
* Click the [C**reate New Test Case**](/test-and-quality-management/test-management/test-cases/test-case-creation) button to start a new validation scenario.
* Click "**Add Step"**, then type “/” inside the step field. From the dropdown menu, choose **Test Case Type** and select **API**. This allows you to configure structured API validation steps without writing manual code.
* Select the required HTTP Method (GET, POST, PUT, DELETE, PATCH).
* Enter the Request URL. You can use variables inside the URL if needed.
* Use the available tabs to configure the request:
* In **Params**, add query parameters as key-value pairs.
* In **Authorization**, select the required authentication type such as Bearer Token, Basic Auth, API Key, OAuth, JWT, etc.
* In **Headers**, add the necessary request headers.
* In **Body**, choose the required body type such as JSON, Form Data, Raw, x-www-form-URL encoded, or Graph, and provide the payload if needed.
* In **Variables**, manage Local, Runtime, and Global variables.
* In **Extractions**, define rules to capture values from the API response for use in subsequent steps.
* In **Pre-request Script**, add logic that should execute before the request is sent.
* In **Tests**, define validations to verify response status codes and response data.
* Enter the step description in simple English to clearly describe the API validation scenario.
* To reuse an existing parameter, type `${` to open the parameter dropdown and select the required variable. To create a new parameter, refer to the Create New Parameter section for guidance.
* Once all steps and configurations are completed, click **Save** to store your test case in the dashboard.
* Run the created API test case using either:
* **Manual Mode** for step-by-step validation.
* **Automation (WalnutAI) Mode**, where WalnutAI automatically sends the request, resolves parameters, processes variables, performs validations, and generates structured execution results.
To understand the details of running your tests and how the system handles changes, refer to the documentation on[ Execution & AI Healing.](/test-and-quality-management/test-management/execution-and-ai-healing)
# How to create DB test case
A Database Test Case is a structured validation scenario designed to verify data integrity, data accuracy, and backend database operations.
* It connects to a configured database.
* Executes SQL queries or operations.
* Validates returned results to ensure correct data storage and retrieval.
#### **Steps to Create a DataBase Test Case**
* Click "[**Create New Test Case**](/test-and-quality-management/test-management/test-cases/test-case-creation)**"** to start a new validation scenario.
* Click **Add Step**, type “/” inside the step field.
* From the dropdown, choose "**Test Case Type"**.
* Select "**Database"** to configure structured DB validation steps without writing manual automation code.
* Select the required **Database Type**.
* MySQL
* PostgreSQL
* MSSQL
* MongoDB
* Configure the database connection using either:
* Standard connection fields:
* Host
* Port
* Database Name
* Username
* Password
* Optional SSL toggle
* OR enable "**Connection String"** toggle and paste the full connection string.
* Click "**Connect"** to establish the database connection.
* Optionally click **Save Connection** to reuse it in future test cases.
* Under **Operation**, choose the required option (e.g., Custom).
* Enter the SQL query in the query editor.
* Or describe the query in plain English and click **Generate Query** to auto-generate SQL.
* Click "**Run Query"** to execute the query and view results.
* Use the available tabs for validation:
* **Results**
* View query execution output.
* Verify returned records.
* **Assertions**
* Validate row count.
* Verify specific column values.
* Check data types.
* Ensure fields are not null.
* **Extract**
* Capture values from query results.
* Store values for reuse in later steps.
* **Test Data**
* Manage datasets for parameterized execution.
* You can use variables inside queries:
* Global Variables → Type `$(`
* Local Variables → Type `${`
* Runtime Variables → Type `$[`
* To reuse an existing variables:
* Type `${` and select the required variable from the dropdown.
* Enter the step description in simple English to clearly describe the database validation scenario.
* Example: “Verify active users are returned from users table.”
* Example: “Validate user record is inserted successfully.”
* Once configuration is complete, click **Save** to store the test case.
* Run the created DB test case using:
* **Manual Mode**
* Execute step-by-step validation.
* **Automation (WalnutAI) Mode**
* Automatically connects to database.
* Executes queries.
* Resolves variables and parameters.
* Performs assertions.
* Extracts values.
* Generates structured execution results.
* For more details on execution flow and intelligent handling of changes, refer to the documentation on [**Execution & AI Healing**.](/test-and-quality-management/test-management/execution-and-ai-healing)
# Execution & AI Healing
**Test Execution**
Once your test case is saved, click on **'Run Test'** to initiate the validation process. WalnutAI provides two primary modes of execution to fit different testing requirements:
* **Automation Mode:** WalnutAI automatically executes the defined steps using your configured objects and parameters to ensure rapid, consistent validation.
* **Manual Mode:** This allows you to execute the test step-by-step, providing the flexibility to log actual results, upload evidence, and manually mark each step as Pass or Fail.
**AI Healer**
WalnutAI includes an intelligent recovery system to handle the common issue of brittle tests failing due to minor application changes.
* If a test fails due to UI changes or object mismatches, you can trigger the AI Healer directly via the chat interface.
* The AI automatically analyzes the failure to detect the underlying issue, such as a renamed button or a shifted element.
* The system suggests the required updates, allowing you to review the changes and fix the step immediately without manual debugging.
* This proactive approach ensures continuous quality monitoring by resolving misalignments between intent and code before they become technical debt.
After execution, navigate to the Reports section to view detailed test case results and execution summaries.
# Defects
Defects in WalnutAI are managed within the **Action Items** module, providing a centralized place to track, assign, and resolve issues identified during testing.
Defects can be logged directly from failed test executions or created from the **Action Items** screen whenever required. Once created, they can be linked to test cases and user stories, ensuring complete traceability across requirements, testing, and defect management.
From the **Action Items** screen, you can:
* Create and manage defects.
* Assign defects to team members.
* Update defect details, priority, and status.
* Link defects to test cases and user stories.
* View all associated test cases and requirements from the defect.
By centralizing defect management within Action Items, WalnutAI helps QA teams, developers, and product owners collaborate efficiently while maintaining complete visibility into every issue from creation to resolution.
# Report Defects from Execution Reports
When a test step fails during execution, you can log a defect directly from the execution report without manually entering all the required information. WalnutAI automatically captures the execution context and generates a comprehensive defect, reducing the time spent on defect reporting while improving the consistency and quality of defect documentation.
The generated defect includes:
* **Defect Summary** – A meaningful summary generated from the failed test step.
* **Defect Type** – Identifies whether the defect was discovered during a Manual or Automated test execution.
* **Root Cause** – Captures the reason for the failure based on the execution results.
* **Failed Step Details** – Identifies the exact step where the test failed, along with the expected outcome and the actual result observed during execution.
* **Steps to Reproduce** – Automatically generates reproducible steps based on the executed test flow, making it easier for developers to recreate the issue.
* **Suggested Fix** – AI provides an initial recommendation that can help developers understand and resolve the problem faster.
* **Automatic Test Case Association** – The defect is automatically linked to the test case from which it was created, ensuring complete traceability without any additional effort.
By automatically capturing the execution details and contextual information, WalnutAI enables developers to begin investigating issues immediately without requiring QA engineers to manually document every aspect of the failure.
# Link Existing Defects to Test Cases
A single defect may impact multiple test cases. Instead of creating duplicate defect records, WalnutAI allows you to associate an existing defect with any number of test cases.
**To link a defect to a test case:**
* Open the required **Test Case**.
* Click **Defects** from the top-right panel.
* Select **Link Defect**.
* Choose the required defect from the list.
* Click **Done**.
* The selected defect is now associated with the test case.
Linking existing defects helps maintain a single source of truth for an issue while providing complete visibility into every test case affected by that defect. This simplifies defect tracking, avoids duplicate records, and makes regression validation easier.
# Link Existing Defects to User Stories
Defects can also be associated directly with user stories or requirements, allowing teams to understand which business requirements are impacted by a particular issue.
**To link a defect to a user story:**
* Open the required **User Story**.
* From the right-side panel, click **Link Defect**.
* Select the appropriate defect from the list.
* Click **Done**.
* The selected defect is now associated with the user story.
By linking defects to requirements, product owners, business analysts, QA engineers, and developers can quickly identify all issues affecting a user story, improving requirement traceability and ensuring every impacted requirement is addressed before release.
# View Associated Test Cases and User Stories
WalnutAI provides complete traceability by allowing you to view all associated test cases and user stories directly from the defect.
When you open a defect, the linked test cases and user stories are displayed, giving you immediate visibility into the validation scenarios and business requirements affected by the issue.
**This enables teams to:**
* Identify all test cases associated with the defect.
* View the user stories or requirements impacted by the issue.
* Understand the overall scope and impact of the defect.
* Ensure every affected test case is revalidated after the defect has been resolved.
Having these relationships available from the defect itself improves collaboration across QA, development, and product teams while making it easier to prioritize fixes and track the progress of an issue throughout its lifecycle.
# Test Suites
A Test Suite in WalnutAI is a logical package used to group related test cases for organized management and execution. Instead of triggering tests individually, a suite allows you to execute multiple cases as a single, cohesive unit.
#### Why Use Suites?
Using suites simplifies your testing workflow and provides several key advantages:
* **Organized Testing:** Group test cases by feature, module, or release.
* **Faster Execution:** Trigger dozens of test cases simultaneously with a single click.
* **Centralized Visibility:** Access all execution results and data-driven insights in one location.
* **Simplified Maintenance:** Easily add or remove cases as your application evolves without recreating the underlying tests.
* **Granular Reporting:** Analysis is available at both the high-level suite view and the individual test-step level.
# Creating and Adding Test Cases to a Suite
#### **Steps to Create a Suite**
* **Navigate to Suites:** Go to the Test Cases module and click the **'Suites'** tab located next to it.
* **Initialize:** Click Create **'Suite'**.
* **Define Details:**
* Suite Name: Provide a unique, descriptive label.
* Description: Add context regarding the suite's purpose.
* **Status:** Switch between Active and Inactive.
{% hint style="info" %}
A suite can only be executed when its status is set to Active. If the status is Inactive, the execution button is disabled.
{% endhint %}
* **Save:** Click **'Create Suite'** to finalize.
#### **Steps to Add Test Cases to a Suite**
* Choose the desired test suite where you want to include test cases
* Browse the project’s test case list from the left-hand panel. Select the required test cases and click **'Add Selected'** to include them in the suite or simply drag test cases from the project list and drop them directly into the suite for quick organization.
# Executing & Analyzing a Test Suite
Once your test suite is ready, click **Run Suite** to begin execution. Before the suite starts, select the **execution mode** and the **browser** in which you want to run your tests.
WalnutAI supports both **Automated** and **Manual** suite execution.
* In **Automated** mode, all test cases are executed automatically in the predefined order.
* In **Manual** mode, testers are guided through each test case step-by-step, allowing them to validate the expected outcomes and record the execution results manually.
For browser-based execution, you can choose from **Chromium**, **Microsoft Edge**, **Firefox**, or **WebKit**, making it easy to validate your application across multiple browser environments.
After selecting the execution mode and browser, the system begins executing all associated test cases in the predefined order.
{% hint style="warning" %}
If required, you can click **Stop Execution** at any time to immediately terminate the ongoing suite execution.
{% endhint %}
Once execution is complete, you can review the execution reports directly from the suite interface. The reports provide real-time status updates, detailed execution logs, and pass/fail results for each test case, enabling you to quickly evaluate your application's stability, identify failures, and analyze the overall execution performance.
# Managing Your Suites
* **Updates:** From the Suites directory, you can update suite details, modify the test case list, or re-run executions as needed.
* **Remove Test Cases**: Click on a test case within the suite and select Remove from Suite. This action **does not** delete the test case from your project, it removes the test case from that specific suite.
* **Delete a Suite:** To permanently delete a suite from your workspace, navigate to the Suites directory and use one of the following methods:
* Select the suite from the list and click the Delete Selected button.
* Click the Delete icon associated with the specific suite you wish to remove.
* **Export to Local Device**: You can download your suite for offline review or external documentation. Simply select the suite and click the Export button to save it directly to your laptop or local device.
# Cloud Execution
Cloud execution allows you to run test cases and test suites on remote infrastructure instead of your local machine. WalnutAI connects to the configured compute environment, provisions the required resources, and executes the tests remotely.
Before running tests in the cloud, configure a virtual machine from the Admin settings.
#### Steps to configure a virtual machine
1. Navigate to **Admin settings**.
2. Select **Compute configuration**.
3. Click **Add Machine**.
4. Choose the compute type. WalnutAI supports the following compute providers:
* VM (SSH + Docker)
* Kubernetes (K8s Jobs)
* LambdaTest (Mobile Cloud)
5. Enter the required connection details.
6. **Compute configuration:** Provide a name for the machine that will be displayed while selecting the execution environment.
| Field | Description | Example |
| ----- | --------------------------- | ----------------- |
| Name | Name of the compute machine | Production Server |
| Type | Compute provider | VM |
7. **Configure the SSH connection:** Enter the SSH credentials required to connect to the virtual machine.
| Field | Description |
| --------- | ------------------------------------------- |
| Host / IP | Public or private IP address of the machine |
| Port | SSH port number |
| Username | SSH username |
| Auth type | Authentication method |
| Password | SSH password |
**Example:**
```
Host / IP: 192.168.1.100
Port: 22
Username: root
Auth type: Password
```
8. **Configure agent settings:** Agent settings control how WalnutAI provisions and executes tests on the machine.
9. **Workspace directory:** The workspace directory defines the location where repositories are cloned during execution.
```
~/walnut-workspaces
```
10. **Max concurrent agents**: Specifies the maximum number of WalnutAI agents that can run simultaneously on the machine.
```
5
```
11. **Idle timeout:** Defines the duration, in minutes, after which inactive sessions are terminated automatically.
```
60
```
12. **Max concurrent test cases:** This setting enables cloud execution for the machine.
* Set the value above `0` to enable the VM as a cloud runner.
* WalnutAI automatically detects the machine capacity during provisioning.
* The recommended concurrency limit is populated automatically.
* You can modify the value up to the detected limit.
* Setting the value to `0` disables cloud execution.
13. **Configure project access:**
* Configure project access settings to control which projects can use a particular machine.
* Enable **All Projects** to make the machine available across all projects, or select specific projects to restrict access. If no projects are selected, WalnutAI automatically grants access to all projects by default.
**Set a default machine**
Enable **Set as default machine** to automatically use the configured VM during cloud execution.
**Execute test cases in the cloud**
After the virtual machine has been configured, you can execute test cases in the cloud.
1. Open the required project.
2. Navigate to the test case or test suite.
3. Click **Execute**.
4. Select **Cloud execution**.
5. Choose the configured virtual machine.
6. Start the execution.
WalnutAI provisions the selected machine and executes the test remotely.
# Scheduler
The **Scheduler** allows you to schedule the execution of **Test Cases** and **Suites** at a specific date and time. You can choose to execute them on either a local **Agent** or a **Cloud Machine**, eliminating the need to manually start executions. Scheduled executions can also be viewed, modified, or deleted whenever required.
**Why Use Scheduler?**
* Automates the execution of test cases and suites at a scheduled time.
* Eliminates the need to manually trigger test executions.
* Supports execution on both **Agents** and **Cloud Machines**.
* Enables recurring executions using configurable repeat options.
* Allows scheduled executions to be edited or deleted whenever required.
# Scheduling a Test Case or Suite
**Steps to Schedule a Test Case or Suite**
* Select the required **Test Case** or **Suite** from the project.
* Click the **Scheduler** button available in the top-right corner of the page to open the scheduling window.
* Select the execution target as either an **Agent** or a **Cloud Machine**, depending on where you want the test to run.
* Choose the required **Agent** or **Cloud Machine** from the available list.
* Select the **Environment** in which the test should be executed.
* Choose the preferred **Browser** for execution.
* Enable or disable the **Auto-Heal** option based on your execution requirements.
* From the calendar, select the date on which the execution should be scheduled.
* Click **Add Time Slot**, specify the execution time.
* If the execution needs to run repeatedly, select the appropriate **Repeat** option (for example, daily or weekly). Otherwise, choose **Does not repeat**.
* Click **Add to Schedule** to add the selected time slot to the schedule.
* After reviewing the schedule details, click **Schedule** to save and activate the scheduled execution.
# Managing Scheduled Executions
The **Manage Schedule** page provides a centralized view of all scheduled test case and suite executions. It allows you to monitor scheduled runs, track their execution status, and quickly access important scheduling information from a single location.
From this page, you can manage existing schedules by editing their configuration, retrying executions, pausing scheduled runs, viewing execution reports, or deleting schedules when they are no longer required. The page also displays key details such as the schedule name, execution frequency, next scheduled run, last execution, assigned execution target, and current execution status to help you efficiently manage all scheduled executions.
#### Steps to Manage Scheduled Executions
* From the **Test Management** page, click **Manage Schedule**.
* The **Schedule Execution** page opens and displays all scheduled **Test Cases** and **Suites**.
* Use the **Search** bar to quickly find a scheduled test case or suite.
* Filter schedules based on their execution **Status** using the status dropdown or additional **Filters**.
* Select **Agents** or **Cloud Machines** from the left panel to view schedules assigned to a specific execution target.
* Click the **More** menu for a scheduled item to perform the required action:
* **View Suite Report:** Opens the execution report for the selected scheduled suite, allowing you to review the execution summary, individual test case results, logs, screenshots, and failure details.
* **Edit:** Opens the schedule configuration page where you can modify the execution target, environment, browser, execution date and time, recurrence settings, and other scheduling options.
* **Retry Now:** Immediately triggers the execution of the selected scheduled test case or suite using the existing schedule configuration, without waiting for the next scheduled run.
* **Pause:** Temporarily suspends the scheduled execution, preventing it from running at its configured time until the schedule is resumed.
* **Delete:** Permanently removes the selected scheduled execution from the scheduler. Once deleted, it will no longer execute automatically unless a new schedule is created.
# Download and Set Up Agent
Setting up the Agent in WalnutAI is a simple and structured process that allows you to enable smart recording, test execution, and AI-powered actions from your system.
### Why is Agent necessary?
* Enable **Smart Recording**
* Perform **Test Execution**
* Run **AI-powered actions**
The setup is completed in four main steps:
#### Access Agent & Download
Click on the **Agent icon** located at the top right corner next to your profile.
You will see the Agent panel with options like:
* Start Agent
* Test Connection
* Download Agent
Click on “**Download Agent**,” and the system will automatically detect your device and display the appropriate option—Windows or Mac
The agent file (e.g., `.exe` for Windows and `.dmg` for Mac) will be downloaded to your system.
#### Install & Launch Agent
* Open the downloaded file and complete the installation.
* Once installed, launch the Agent on your system.
#### Make the Agent available
After launching the Agent:
* Click on **Start Agent** from the Agent panel
* A browser popup will appear asking to open WalnutAI
* Click on **Open WalnutAI Agent**
* The agent status will change from **Offline** to **Online**
* A **green indicator** will appear, confirming the agent is connected
#### Update Agent
Go to the installed Agent on your system.\
Right-click on the Agent icon and click on **Update Agent**.
* The update will install automatically
* If a new version is available, an **Update Available** notification will be shown
This process ensures your agent is installed, updated, and running successfully.
# Reports
The **Reports** module in WalnutAI provides a centralized view of all test execution activity across your project. It captures and organizes execution results, logs, screenshots, performance data, and diagnostic details into a structured reporting interface.
Every time a test case or test suite is executed whether manually or through automation WalnutAI automatically generates a unique **Test Run ID** and records the complete execution history. This ensures full visibility, traceability, and accountability for every run.
The Reports module acts as the single source of truth for monitoring execution health and validating release readiness.
**Why Use Reports?**
The Reports module plays a critical role in quality monitoring and release validation:
* **Execution Visibility:** View the status of all test runs in one place.
* **Failure Investigation:** Access step-level logs, screenshots, and error details to quickly identify root causes.
* **Release Validation:** Review pass/fail trends before approving a build.
* **Trend Analysis:** Monitor stability over time and detect patterns in recurring failures.
* **Audit & Traceability:** Maintain a permanent execution history for compliance and tracking.
Reports enable teams to make informed, data-driven decisions by transforming raw execution data into clear and actionable insights.
# Test Case Reports
The **Test Case Reports** page provides detailed visibility into individual test case executions. It allows you to monitor execution status, review trends, and inspect step-level results.
* **How to Access Test Case Reports** -**Path:** "Reports" → "Execution Reports" → "Test Cases"
* Click **"Reports"** from the left navigation panel.
* Click on the **"Test Cases"** tab.
* **What You See on the Test Cases Page**: The **Test Cases** page is divided into three main sections that help you quickly review execution results.
1. **Filters Section** – Allows you to narrow down execution data.
2. **Execution Analytics Section** – Provides visual summaries of execution trends and status.
3. **Execution Results Table** – Displays detailed information for each test run.
* **Filter Execution Results**: You can use filters to refine the execution data shown on the page.
* **Date Range** – View executions within a specific time period.
* **Status** – Filter by Passed, Failed, or other statuses.
* **Test Case** – View results for a specific test case.
* **Suite** – View executions linked to a particular suite.
* **Execution Analytics**: The **Analytics Section** provides visual summaries to help you quickly understand execution performance and stability.
* Test Execution Trend – Displays pass and fail results over time.
* **Green** – Passed, **Red** – Failed, **Blue** – Not Executed, helping you quickly identify execution stability and trends across multiple test runs.
* Test Run Distribution – Shows overall execution breakdown in a donut chart.
* **Total Runs** – total executions, **Passed** – successfully completed runs, **Failed** – runs with issues, **Not Executed** – runs not completed, providing a quick summary of overall execution health.
* Click **"Apply"** to update the results.
* Click **"Reset"** to clear all selected filters.
* **Execution Results Table:** The **Execution Results Table** displays detailed information for each test run, allowing you to review execution history in a structured format.
* **Execution Date** – Shows when the test was executed.
* **Test Run ID** – Unique identifier generated for each execution.
* **Test Case ID** – Identifies the associated test case.
* **Test Case Name** – Name of the executed test case.
* **Duration** – Total time taken for execution.
* **Status** – Indicates Passed, Failed, or other execution states.
* **Executed By** – Displays who triggered the execution.
# Detailed Execution Report
* Click on a **Test Run ID** from the Execution Results Table.
* You will be redirected to the **Detailed Execution Report** page for that specific run.
What You See on This Page:
* **Execution Summary Section** – Displays overall run information.
* Test Case Name and ID
* Version and Run count
* Execution Environment
* Executed By
* Execution Date & Time
* Overall Status (Passed / Failed / Pending)
* Total Duration
This section gives a quick overview of the execution result.
* **Multiple Iterations (if applicable)**\
If the test case is executed with multiple iterations (e.g., different test data sets), each iteration is grouped under a single test run in the report.
* The total number of iterations is displayed (e.g., **“5 iterations”**)
* Execution result is shown as a summary (e.g., **5 Passed / 0 Failed**)
* Each iteration runs the same test with different data inputs
* Steps are executed and recorded for each iteration individually
* Helps compare results across different data inputs and identify failures specific to certain iterations
* You can click on the test run to view detailed step-level results for each iteration
* **Step-Level Results Section** – Shows all executed steps in order.
* Step Number
* Status (Passed / Failed)
* Step Description
* Actual Result
* Test Data
* Execution Time
Each step clearly shows what action was performed and what result was received.
* **Step Filters**- You can filter steps using:
* "All"
* "Passed"
* "Failed"
* "Skipped"
This helps you quickly focus on specific step results.
* **View Step Details**
* Click on any step to open its detailed execution view. This provides complete visibility into what happened during that specific step, including:
* Step input values used during execution
* Step output or response received
* Execution time taken for the step
* Screenshot (if captured during execution)
* Status indicator (Passed / Failed)
* When you encounter a failure and want to log a defect, you can click **“Bug”** directly from a failed step, which will automatically create an **Action Item** with the captured error details, step information, and supporting evidence for tracking and resolution.
* The **Detailed Execution Report** gives a clear, step-by-step breakdown of the entire test run, helping you understand the exact behaviour of the application, troubleshoot failures efficiently, and maintain complete execution traceability.
# Suites Reports
The **Suite Reports** page provides visibility into test suite executions. It allows you to monitor execution results and review the test cases executed within each suite.
* **How to Access Suite Reports Path:** **Reports → Execution Reports → Suites**
* Click **Reports** from the left navigation panel.
* Click on the **Suites** tab.
**What You See on the Suites Page:**\
The Suites page is divided into two main sections that help you review suite execution results.
* **Test Suites Section** – Displays the list of available test suites along with their execution summaries.
* **Execution Results Table** – Shows detailed execution results for the selected suite.
**Test Suites Section:** The Test Suites panel lists all available suites.
For each suite you can see:
* **Suite Name** – Name of the test suite.
* **Run Count** – Number of times the suite has been executed.
* **Pass / Fail Count** – Number of test cases passed or failed within the suite.
* Click on a suite to view its execution history.
* **Execution Results Table:** The Execution Results Table displays detailed information for each test execution within the selected suite.
* **Executed At** – Shows when the test case was executed.
* **Test Run ID** – Unique identifier generated for the execution.
* **Test Case ID** – Identifies the associated test case.
* **Test Case Name** – Name of the executed test case.
* **Duration** – Total time taken for execution.
* **Status** – Indicates Passed or Failed.
* **Executed By** – Displays who triggered the execution.
**Multiple Iterations in Suite Execution -**If a test case within a suite is executed with multiple iterations (using different test data), the execution results are grouped under a single test run in the Execution Results Table.
For such executions, you will see:
* **Iteration Count** – Displays the number of iterations executed (e.g., *“2 iterations”*) below the Test Case Name
* **Execution Summary** – Shows a combined result for all iterations (e.g., *2 Passed / 0 Failed*)
* **Single Test Run Entry** – All iterations are grouped under one Test Run ID instead of separate rows
* **Consistent Test Case Execution** – The same test case is executed multiple times with different data inputs
* **Clear Result Visibility** – Helps quickly understand overall success/failure across all iterations
You can click on the **Test Run ID** to navigate to the Detailed Execution Report, where each iteration and its step-level execution can be reviewed individually.
# Analytics
**Analytics** allows you to monitor AI usage, cost, and operational activity across your project or organization. It provides real-time visibility into token consumption, model usage, cost distribution, and feature level activity, ensuring AI usage remains measurable, transparent, and controlled.
The Analytics dashboard helps you track how these operations impact usage and spending.
**Access Analytics :**
* Click **Analytics** from the left navigation panel.
**Switch Between Project and Organization View**
* Use the **Project / Organization** toggle at the top-right corner to change the data scope.
* **Project View**
* Displays AI usage for the selected project only.
* Monitor AI calls within the project.
* Track token usage and cost trends.
* Review story and test generation activity.
* **Organization View**
* Displays aggregated data across all projects.
* Monitor enterprise-wide AI consumption.
* Compare project-level spending.
* Track overall adoption.
* Useful for budgeting and governance discussions.
#### Filter by Date Range (Project & Organization Level)
* Use the date selector to adjust the reporting period for analysis.
* Available options include Last Day, 7 Days, 1 Month, All Time, and Custom Date Range.
* Applies to both project-level and organization-level views.
* All graphs and metrics automatically update based on the selected date range.
**Project View Metrics**
* Total Stories – Number of stories created.
* Test Cases – Number of test cases generated.
* AI Calls – Total AI engine invocations.
* Total Spend – AI cost and token consumption.
* Each Gap Analysis run, repository scan, story generation, or document processing counts as one AI call.
**Analyse Usage Trend (Project Level)**
* The Usage Trend graph shows token consumption over time for the selected project.
* Each data point represents usage for a specific day.
* Spikes indicate heavy AI operations, while flat lines indicate low activity.
* Helps identify peak usage days and unusual cost increases.
* Enables monitoring of usage patterns across the project.
* Large Gap Analysis runs or repository scans may cause noticeable spikes.
**Monitor Budget Status (Project Level)**
* The Budget Status section shows whether a spending limit is configured.
* If unlimited usage is enabled, AI operations continue without restriction.
* If limits are configured, usage may be governed by budget rules.
* This is important for financial control and governance.
**Analyse Cost by Model (Project Level)**
* The Cost by Model chart displays how AI model usage cost is distributed within the selected project.
* Helps identify which model (e.g., Claude Sonnet) is contributing most to project-level cost.
* Enables teams to evaluate cost efficiency at a project level.
* Supports optimization by adjusting model usage based on cost and performance needs.
**Analyse Usage by Operation (Project Level)**
* The Usage by Operation chart shows token consumption for different features within the selected project.
* Helps identify which operations (e.g., Phase 2 Story Validation, Phase 3 Code Quality Analysis) are consuming more tokens.
* Enables better tracking of feature-wise usage within the project.
* Helps optimize usage by reviewing high-consumption operations and reducing unnecessary runs.
**Monitor Stories by Status (Project Level)**
* Displays story distribution across workflow stages such as:
* Draft
* Approved
* In Progress
* Completed
* Connects AI-generated output with execution progress.
**Team Activity (Project Level)**
* Displays team member activity within the project
* Shows AI calls, tokens, tests, executions, and last active time
* Helps track contributions and engagement
**Feature Adoption (Project Level)**
* Shows how different features are used within the project
* Identifies most and least used features
* Helps improve feature utilization
**Quality Overview (Project Level)**
* Displays Total Executions, Pass Rate, Average Duration, and Defects Found
* Helps assess overall testing quality
* **Most Failed Tests (Project Level)**
* Highlights test cases with the highest failures
* Shows pass %, failures, and total runs
* Helps identify unstable tests
* **Model Performance (Project Level)**
* Displays model response time, usage, and cost
* Helps evaluate efficiency and performance
**Dashboard Settings (Project Level)**
* Dashboard Widgets
* Enable or disable widgets for the project dashboard
* Customize dashboard based on needs
* **Export Data**
* Export analytics data as CSV
* Useful for reporting and sharing
* **Preferences**
* Set default date range
* Options: Last Day, 7 Days, 30 Days, All Time
**Organization View Metrics**
* Total Projects – Active projects in the organization.
* Total Tokens – Combined token usage.
* AI Calls – Total AI invocations.
* Total Spend – Aggregated AI cost.
* Token usage directly impacts AI spend.
**Analyse Usage Trend (Organization Level)**
* The Usage Trend graph shows token consumption over time across the organization.
* Each data point represents usage for a specific day.
* Spikes indicate heavy AI operations, while flat lines indicate low activity.
* Helps identify peak usage days and overall cost trends.
* Enables monitoring of usage patterns across multiple projects.
* Large operations such as Gap Analysis or repository scans across projects may cause noticeable spikes.
**Review Organization Summary (Organization Level)**
* Displays high-level enterprise metrics such as:
* Total active projects.
* Total AI spend.
* Useful for executive reporting and strategic oversight.
**Analyse Cost by Model (Organization Level)**
* The Cost by Model chart shows how spending is distributed across configured AI models.
* Helps you:
* Identify high-cost models.
* Evaluate model efficiency.
* Optimize AI configuration.
**Analyse Usage by Operation (Organization Level)**
* The Usage by Operation chart shows how token consumption is distributed across different features.
* Operations may include Gap Analysis, Analyse Multi Repository, Story Generation, Test Case Generation, Code Generation, Document Processing, and Duplicate Detection.
* Helps identify which operations are consuming more tokens.
* Enables optimization by reviewing the frequency and scope of high-consumption operations.
**Review Cost by Project (Organization Level)**
* The Cost by Project chart shows how AI spending is distributed across different projects within the organization.
* Helps identify high-spending projects.
* Enables better budget allocation across projects.
* Ensures accountability by tracking project-wise AI usage and cost.
**Team Activity (Organization Level)**
* Displays activity across all projects
* Tracks AI calls, tokens, tests, executions
* Helps monitor team productivity
**Feature Adoption (Organization Level)**
* Shows feature usage across projects
* Identifies adoption trends
* Helps improve feature utilization
**Dashboard Settings (Organization Level)**
* **Dashboard Widgets**
* Enable/disable widgets across organization dashboard
* **Export Data**
* **Export organization analytics data**
* Preferences
* Set default date range for organization view
**Why Analytics Matters**
The Analytics page centralizes AI visibility in one dashboard. Instead of manually tracking cost or reviewing multiple modules, you can:
* Monitor token consumption.
* Track AI calls.
* Analyse operational distribution.
* Control spending.
* Maintain governance.
It supports both project-level optimization and organization-wide financial oversight, ensuring AI usage remains efficient, transparent, and aligned with business goals.
# Requirement Traceability Matrix (RTM)
Managing a growing list of requirements across a product lifecycle is one of the biggest challenges in software development and QA. Without clear visibility, critical requirements get missed, test coverage has blind spots, and a single change can create unpredictable failures across the system.
Consider a banking application with a requirement like *"Users must receive an OTP for secure login."* That one requirement touches user stories, test cases for valid, expired, and incorrect OTP scenarios, and potentially multiple defects. When something breaks for instance say, the OTP isn't delivered — tracing the root cause without end-to-end requirements traceability is slow, manual, and error-prone.
The **Requirement Traceability Matrix (RTM) in WalnutAI** solves this with a clear, visual mapping of how requirements flow across your entire product lifecycle from -
**Epics → Features → User Stories → Test Cases → Defects**
It gives teams a single source of truth to answer the three questions that matter most at any point in a project:
* **Was everything asked for actually built?**
* **Was everything built actually tested?**
* **If something changes, what else is affected?**
```mermaid
graph TD
E[Epic: Users must receive OTP for secure login]
US1[User Story: Request OTP]
US2[User Story: Validate OTP]
TC1[Test Case: Valid OTP]
TC2[Test Case: Expired OTP]
TC3[Test Case: Incorrect OTP]
D1[Defect: OTP Not Delivered]
E --> US1
E --> US2
US1 --> TC1
US2 --> TC2
US2 --> TC3
TC1 --> D1
```
**Why RTM Matters for Your Team?**
* **Ensures complete test coverage:**\
Every requirement is mapped to one or more test cases, ensuring that all functionalities including edge cases are validated. This reduces the risk of untested features reaching production.
* **Simplifies impact analysis:**\
When a requirement changes, RTM allows teams to instantly identify the affected test cases, user stories, and features, enabling quick and targeted updates without rechecking the entire system.
* **Improves accountability and quality:**\
By clearly linking requirements to tests and outcomes, teams can ensure that every business need is properly implemented and validated, reducing missed functionality and improving overall product quality.
* **Supports audits and compliance:**\
RTM provides structured traceability from requirements to testing and defects, making it easier to demonstrate validation during audits especially important in regulated industries.
**Workflow Example**
**EPIC:** Dashboard\
⬇ **Feature:** Main Dashboard Display\
⬇ **User Story:** PROJ-0b6 – View dashboard with penyeteman case list and filter options\
⬇ **Test Cases:**\
• TC\_2685\_013 – Validate error message for empty date range\
• TC\_2685\_015 – Validate error scenarios\
• TC\_2685\_014 – Validate error variations\
• TC\_2685\_006 – Validate error notifications\
• TC\_2685\_005 – Validate invalid end date\
• TC\_2685\_016 – Validate multiple invalid inputs\
• TC\_2685\_007 – Validate redirect to login
**Summary Metrics:** At the top of the RTM screen, summary metrics provide a quick snapshot of project progress:
* EPICs: Total number of epics (e.g., 10)
* Features: Features linked to epics (e.g., 14)
* User Stories: Total user stories (e.g., 566)
* Test Cases: Test cases created (e.g., 55)
* Defects: Total defects identified (e.g., 4163)
**Visual Traceability Graph:** RTM presents relationships in a hierarchical structure for easy understanding:
* EPICs appear as top-level nodes
* Features branch from EPICs
* User Stories expand from Features
* Test Cases link to User Stories
* Defects connect to Test Cases
Each node is interactive clicking on EPICs, Features, User Stories, Test Cases, or Defects opens detailed views for deeper insights and actions.
**Key Features and Benefits**
* **End-to-End Traceability:** Track requirements seamlessly across the entire lifecycle
* **Dynamic Filtering:** Filter by release, status, or priority for focused insights
* **Hierarchical Visualization:** Clearly understand relationships and coverage
* **Interactive Drill-Down:** Navigate quickly to detailed views through clickable nodes