AI Agents in Wrike
TL;DR:
AI Agents in Wrike are smart assistants that help your team work more efficiently by monitoring projects, analyzing context, and taking action. You can use prebuilt agents or create custom ones. Only Space admins can set them up. Agents work best with clear, descriptive text and can only access data within their assigned scope.
|
Availability: Business, Pinnacle, Apex. ; Unavailability: Free, Team; |
AI Agents in Wrike are intelligent assistants designed to help your team work more efficiently. They monitor your projects, analyze context, and perform actions such as detecting risks, categorizing requests, or validating details. You can choose from prebuilt agents or create custom ones to suit your needs.
Note
AI Agents are currently available only in spaces and can be configured by Space admins.
Important
AI Agents requires the AI Addendum to be signed, as it’s powered by Large Language Models, which require your acceptance of the Terms and Conditions.
If you don’t see the AI Agents button, make sure Generative AI is enabled in your settings to access all AI features.
AI agents bring intelligence and automation to your workflows:
-
Intelligent analysis: Read task descriptions, comments, and context to make informed decisions.
-
Proactive monitoring: Watch for risks, bottlenecks, and opportunities.
-
Smart classification: Organize and route work based on content understanding.
-
Quality assurance: Validate incoming requests for completeness.
-
External integration: Changes made via the Wrike API also trigger agents, enabling integration with external systems and tools.
Agents can post comments, update fields usually within seconds of detecting a change.
Beyond the triggered item itself, agents can access additional context:
-
Parent item custom fields: The agent can read custom field values from the parent task or project. This means an agent acting on a subtask can consider the parent project’s status, priority, or other fields before deciding what to do.
-
Sibling and subtask items: The agent can see sibling items and subtasks. This enables cross-item reasoning - for example, checking if other subtasks are also overdue before flagging a risk.
-
Location context: The agent knows where it sits in the space and account hierarchy, which helps with routing and classification decisions.
Example: An agent triggered on a subtask can check the parent project’s “Client” field to determine which team should be assigned, without the subtask needing its own Client field.
AI Agents operate in two phases:
-
Watcher: Monitors spaces, projects, or folders for triggers (like new tasks or field changes).
-
Do-er: Analyzes the situation and takes action - posting comments, updating fields, or notifying teammates.
Note
Response time is typically 2–5 seconds as the agent thinks through the best next step. Processing may take longer for larger items or when actions are applied in bulk, such as mass assignee changes.
You can start with three built-in agents or design your own custom agent:
-
Risk Agent
-
Purpose: Identify potential project risks early.
-
What it does: Scans projects, tasks for overdue or blocked items and posts a summary comment.
-
Ideal for: Project managers who want a quick project health check.
-
Setup tip: Schedule daily or weekly runs; the agent posts its risk report as a comment automatically.
-
-
Triaging Agent
-
Purpose: Classify and route incoming work based on content.
-
What it does: Reads new task descriptions, identifies intent, and sets custom field values like priority or category.
-
Ideal for: Teams with high volumes of incoming requests.
-
Setup tip: Define which custom fields to populate and the classification options.
-
-
Intake Agent
-
Purpose: Validate that new requests contain all required details before work begins.
-
What it does: Reviews task descriptions for missing info and posts validation comments.
-
Ideal for: Teams that rely on structured request intake.
-
Setup tip: Define what “complete” means for your team (e.g., deadline, design link, assignee).
-
Custom Agent
-
Purpose: Build your own intelligent automation tailored to your workflow.
-
What it does: You define the role, logic, and triggers; choose actions like posting comments or updating fields.
-
Ideal for: Advanced teams that want to automate unique workflows.
-
Setup tip: Write a clear prompt describing what the agent should look for, how to decide, and what to do in each case. Test it in the Playground before deploying.
You’ll need Space admin permissions to set up AI agents. Agents operate at the space level, and each one must be appointed to a specific folder, project, or task.
-
Navigate to the space where you want to create an agent, then click the Settings icon 1 next to the space overview in the sidebar or below the space title in the overview.
-
Select AI agents tab 2 in the space settings overview and click Get started 3.
-
Choose an agent type from the drop-down 4 (Triaging, Intake, or Risk) or click + Custom AI agent 5 to create your own custom agent.
-
Configure details:
-
Name your agent.
-
In General instructions, describe the agent’s role, goal, logic, expected actions, and fallback behavior. Add example inputs/outputs if it helps you clarify the behavior.
Example: “You act as a project assistant. You monitor assigned work, flag risks, and keep teams aligned by updating work items and leaving clear, actionable comments.”
-
Choose when the agent should trigger:
-
Scheduled agents (for example, a risk status reporter): set how often the agent runs (Daily, Weekly, or Custom).
-
Event-based agents: select triggers such as New item created or Field value changes (for status or other fields).
-
Date-based agents: trigger the agent relative to a date field value, such as "3 days before Due Date" or "When Start Date is reached". Works with Date and Date-time custom fields, and supports working days calculation. Ideal for reminders, escalations, and deadline-based actions.
-
API-triggered agents: changes made via the Wrike API also trigger agents, enabling integration with external systems.
-
Wrike Automations integration: Agents work bidirectionally with Wrike Automations. Traditional automation rules can trigger agents, and agent actions can activate automation rules. This enables complex multi-step workflows combining AI reasoning with rule-based automation.
Note
AI agents can read and react to these custom field types: Text, Number, Percent, Currency, Date, Single Select, Multi Select, Duration, Checkbox, Link to Database, Mirrors, and Calculated/formula fields.
In addition to custom fields, agents can read:
-
Author and assignee of the work item
-
Empty custom fields - agents can reason about what’s missing, not just what’s present
-
Calculated/formula fields - can expose system data agents can’t access directly, such as capacity, workload, or scheduled hours
-
Parent item custom fields - agents can read custom fields from the parent task or project
-
Sibling and subtask items - agents can see sibling items and subtasks for cross-item reasoning
-
Location context - agents know where they sit in the space and account hierarchy
-
-
Set the scope when the trigger should happen:
-
Any subitem of the work item where the agent was added:
Use this for task-level actions, like Intake or Triage. The agent reacts to changes in subitems and acts on those subitems.
Example: The Intake agent is added to an Incoming Requests folder. When a new subitem is added to this folder, it triggers the agent to check if all required information (like assignee or due date) is provided. The agent then posts a comment to that subitem to inform you if anything is missing.
-
Item where the agent was added:
Use this for aggregate actions, like a risk reporter. The agent reacts to changes in this item and acts on this same item.
Example: A custom agent is added to a Product Launch project to notify followers about the changes to the project. If any of the project’s custom fields change, the agent posts a comment to a project about this change and @mentions all the followers.
-
-
Define an action:
-
Post comment: The agent shares its analysis or decision as a comment on the relevant item.
-
Update field values: The agent updates specific fields such as Assignee, Custom field, Item name, or Status.
-
Change custom field: The agent will update specific custom fields (choose which field to update).
Note
AI agents can update these custom field types: Text, Single Select, Multi Select, Number, Percent, Currency, Link to Database.
-
Change assignee: The agent will assign work items to users based on availability, workload, and criteria you define (see detailed configuration below).
-
Change work item name: The agent will update the task or project title based on its analysis.
-
Change status: The agent will update the task status based on conditions you define. Works with both standard and custom workflows.
-
Select Link-to-Database record: The agent can change which database record is selected in Link-to-Database fields. Use this when agents need to categorize items by selecting from your database records.
Note
Link to Database context access:
-
Change L2DB Field action: Agent can search the entire database. Search by value, not by column name.
-
Other actions (Post Comment, Change Status, etc.): Agent sees only the currently selected value, not the full database.
Example
-
✅ “select the record containing the value”
-
❌ “select the record where Column Name is value”
-
-
Change start/due date: The agent can modify start and due dates on tasks. Use this for deadline management workflows, such as pushing a due date when a task is blocked or setting a start date based on intake criteria.
Example prompts:
-
“When status changes to Blocked, push the due date forward by 5 working days.”
-
“When all required fields are filled, set the start date to today.”
-
-
Choose where the update should happen:
-
Work item where the agent was added
-
All subitems of the work item where the agent was added
-
Work item where the trigger happened.
Note
You can add multiple actions by clicking + Action, so the agent can perform several updates in one run.
Important
How multiple actions work
-
Actions are independent - the result of one action does not affect other actions.
-
There is no guaranteed execution order.
-
Each action has its own instruction and can target a different location (parent item, all subitems, or the triggered item).
-
The General instruction is shared across all actions, while each action has its own specific prompt.
This means: If you need Action B to use the result of Action A, a single multi-action agent won’t work. Instead, use agent chaining: Agent 1 performs an action (e.g., sets a field) → Agent 2 triggers on that field change and performs the next step.
Good use cases for multi-action agents:
-
Set a category field AND post a classification comment (no dependency)
-
Change assignee AND update status (no dependency)
-
Update multiple custom fields simultaneously
When to Use Status Change:
Status change is ideal for automatic workflow progression:
-
Intake validation: Change status to Ready when all required fields are completed.
-
Overdue tracking: Mark tasks as Overdue when they pass their due date.
-
Dependency detection: Set status to Blocked when dependencies are mentioned in comments.
-
Project completion: Move tasks to Complete when all subtasks are finished.
Important notes about status changes:
-
Agents respect your workflow transition rules and cannot skip required statuses.
-
Status changes are logged in the task activity history with the agent's reasoning.
-
If the status is already correct, the agent creates only a log entry (no duplicate comment).
-
Works with both standard Wrike statuses and custom workflow statuses.
Example Status Change Prompts:
-
Mark overdue tasks:
When a task passes its due date and status is not Completed, change status to Overdue.
-
Validate intake completion:
When a task has all three required fields populated (Budget, Assignee, Deadline), change status from New to Ready for Work. Ignore tasks already marked Ready for Work or Completed.
-
Detect blocked work:
When comments mention "blocked", "waiting on", or "dependency", and status is not already Blocked or Completed, change status to Blocked and post a comment summarizing what's blocking the task.
-
-
Test your setup in the Testing Playground to see how the agent reasons and responds.
-
Click Create to activate your agent.
-
Appoint the agent to a location: After creating the agent, you must appoint it to the specific folder, project, or task where it should operate. Navigate to the target location and @mention the agent in the comment stream to enable it there. The agent will only monitor and act within its appointed scope.
Important
Creating an agent in Space Settings is not enough - you must also appoint it to a specific location by @mentioning it. Without this step, the agent won't be active.
-
AI agents can automatically change work item names and assign work items to users by analyzing context, availability, and workload. This action is available for Custom Agents and helps your team allocate work dynamically.
When you set-up a Custom AI agent and configure the details as shown in Step 4 above, choose the action to update the Assignee field to assign tasks. The agent will analyze available user information and follow the rules you set in your prompt. The agent can count the tasks it sees assigned to each user, but it does not have access to Wrike’s workload view, capacity planning, or scheduling data. For more accurate workload balancing, use a calculated field that references capacity or workload system data - agents can read calculated field values.
To use Wrike’s AI agent for task assignments, you need to specify a clear pool of users for the agent to choose from. The agent won’t assign tasks to just anyone, you have to guide it by defining exactly who’s eligible. Assigning tasks to a random person without any constraints isn’t supported.
Valid ways to define the user pool:
-
Specify exact users by name: “Assign to Lisa Simpson or Alex Jones”
-
Use built-in groups: “Assign to a random user from My Team”
-
Combine criteria: “Assign to Morgan or Casey if the task mentions ‘design’ or ‘UI’. Among them, prefer whoever has fewer assigned tasks.”
Invalid ways to define the user pool:
-
“Assign to a random user” (no pool defined).
-
“Assign to the best person” (no pool defined).
Important
You must always define a user pool. The agent won’t assign tasks if you don’t provide clear guidance.
Note
My Team is a built-in group that contains all regular users in your account. It does not include Collaborators or External users. You can use My Team in your prompts to reference your entire team.
The AI agent can assign work items using these methods:
-
By full name or user UID.
-
By a unique partial name.
-
To "me" (the person who created the agent).
-
To members of My Team.
-
To members or admins of a user group.
-
To users without specific permissions.
-
To the task creator.
-
To multiple users at once.
-
Across different groups.
-
By location, time zone, job role, department, or country.
-
By workload (such as the least busy person in a group).
-
Using rotation strategies (for example, assigning to a different user each week).
-
With fallback options if no one matches your main criteria.
Current Limitations:
Some assignment options aren’t available yet:
-
Assign to space admins (admin info isn’t passed to the agent yet).
-
Assign based on account roles or permissions.
-
Assign based on user profile attributes (job role, department, timezone, country) - agents see user ID and name only.
-
Assign to the same assignees as another task.
-
Assign to parent task assignees.
-
Read People-type custom fields (cannot assign to a person referenced in a People CF).
Assign using workload metrics, capacity planning, or scheduled hours. The agent can count tasks it sees, but does not have access to Wrike’s workload or scheduling features.
Workaround: Use a calculated field that references capacity data - agents can read calculated field values.
Note
The agent can count tasks it sees, but doesn’t have full access to scheduling or capacity data.
Example Prompts
Here are some ways you can guide the AI agent to assign tasks:
-
Basic assignment:
When a new task is created in this folder, assign it to a member of the Support Team user group who is based in North America.
-
Workload-aware assignment:
Assign new tasks to the user from My Team who currently has the fewest tasks assigned. If multiple users are tied, choose randomly.
-
Rotation strategy:
Rotate task assignment among Design Team members weekly. On Mondays, assign to User A; Tuesdays to User B; and so on.
-
Multi-criteria assignment:
Assign tasks to users who meet these criteria:
-
Member of the Engineering user group.
-
Located in Europe (GMT to GMT+3).
-
Fewer than 10 active tasks.
If no one matches, assign it to the Engineering user group admin.
-
Best Practices
-
Always define your user pool clearly.
-
Include fallback logic for cases where no one meets your criteria.
-
Test your prompts in the Playground before going live.
-
Start with simple rules and add complexity as needed.
-
Document your assignment logic for future reference.
Troubleshooting
If the agent fails to assign anyone:
-
Check that your prompt defines a user pool.
-
Make sure users have the right permissions for the folder or project.
If the wrong person is assigned:
-
Review your prompt for any ambiguous wording.
-
Ensure user profiles are up to date.
-
Test your prompt in the Playground to confirm behavior.
If assignment seems random:
-
Make sure your criteria are specific and clear.
-
Keep in mind that AI agents may occasionally make different choices with similar options.
Note
Regularly review and update your assignment prompts as your team changes or your processes evolve.
Once your agents are deployed, you can monitor their performance in the Agent Activity Dashboard within the AI agents management interface.
Agent Overview Table
See all your appointed agents with details including:
-
Agent name and monthly activity summary (e.g., “5 actions this month”).
-
Recent action timestamps.
-
Action types (such as changing custom fields or posting comments).
-
Work items affected.
-
Trigger events that activated the agent.
-
Success or failure status.
Detailed Action Views
Click any action for more information, including:
-
Complete agent details and timestamp.
-
Specific work item and its location.
-
Exact trigger that activated the agent.
-
Precise action taken (for example, “Update Request Category field to creative asset”).
-
AI reasoning with a full explanation of why the agent made its decision.
Monitoring Best Practices
-
Regular review: Check agent activity logs weekly to make sure agents are working as expected.
-
Reasoning analysis: Use the detailed reasoning display to understand how agents make decisions and spot opportunities to improve prompts.
-
Success rate tracking: Monitor success and failure statuses to catch any ongoing issues.
-
Performance adjustment: Refine agent prompts based on activity logs to boost accuracy and consistency.
Important
-
Always test your agent setup in the built-in playground before deployment. You can select sample items and preview exactly how the agent will respond, including its reasoning process.
-
Set fallback values for cases where the agent can’t make a determination.
-
Agents respect existing permission settings and won’t access information users can’t see.
-
Only one agent of each type can operate in the same location (folder, project, or task).
-
Agents can monitor at the container level (folders or projects) or act on individual work items (tasks), depending on your scope selection.
Chatting with an agent in Wrike lets you ask follow-up questions about actions it takes on your projects and tasks. Use this feature to get insights into the agent’s decisions and reasoning — all in a private conversation.
-
Navigate to the project or task's comment stream where the agent took action.
-
In the comment box, click the AI agent icon in the toolbar to see available agents, or type @ followed by the agent’s name. The AI agent icon filters the picker to show only agents (not regular users), making it easier to find the right agent.
-
A private chat panel will open on the right side of your screen.
-
Type your question and press Enter to chat with the agent.
Note
Your conversation with the agent is private. Other users cannot see what you discuss in the chat panel.
You can use the chat to understand why the agent made certain decisions. For example:
-
Why it took an action:
“Why did you flag this task as at risk?”
-
What information it used:
“What made you classify this as a bug?”
-
How it reached its conclusion:
“Why did you think this was blocked?”
Tip
-
Ask clear, direct questions to get the best answers from the agent.
-
You can copy the answer to your clipboard and like or dislike the response provided by the chat.
Do:
-
Be specific about what you want the agent to look for.
-
Give clear examples of the classifications or actions you expect.
-
Define fallback behaviours for any edge cases.
-
Use natural language - write as if you’re explaining it to a helpful colleague.
-
Test your prompt thoroughly in the Testing Playground before deploying.
Don't:
-
Don’t create overly complex, multi-step logic.
-
Don’t assume the agent understands your company’s terminology without explanation.
-
Don’t forget to address situations with unclear or incomplete information.
-
Don’t deploy your agent without testing it first.
You can include AI agents in Solution Bundle templates for enterprise-wide standardization.
-
Export agents: Include your configured agents when creating a Solution Bundle template. All settings (prompts, triggers, actions, scope) are preserved.
-
Import agents: When importing a Solution Bundle, any included agents are created in the target space with their full configuration.
-
Template preview: Before importing, you can see which AI agents are included in the Solution Bundle.
Use Solution Bundles to standardize agent configurations across multiple spaces, deploy proven agent patterns to new teams, or share best-practice setups organization-wide.
-
Start small: Test one agent type in a single folder before expanding to other areas.
-
Test first: Always validate your agent’s behaviour in the Playground before deploying.
-
Combine agents: Use the Intake Agent and Triaging Agent together for complete request handling.
-
Review often: Regularly refine your prompts based on activity logs and team feedback.
-
Communicate: Keep your team informed when agents are active and let them know what’s being automated.
-
Agent Chaining:
One agent’s action can trigger another agent. This is the recommended approach for workflows where one step depends on the result of a previous step.
How it works: Agent 1 performs an action (e.g., sets a custom field value) → Agent 2 is configured to trigger on that field change → Agent 2 performs the next step.
Examples:
-
Triage → Assignment: A triage agent sets the Priority field → An assignment agent triggers on Priority changes and assigns the task based on the new priority value.
-
Intake → Routing: An intake agent validates a request and sets the status to “Complete” → A routing agent triggers on that status change and moves the item to the correct folder.
-
Categorization → Notification: A categorization agent sets the Type field → A notification agent triggers on Type changes and posts a targeted comment.
When to use chaining vs multi-action:
-
“Does Action B need to know what Action A decided?” → Use chaining (separate agents).
-
“Do I need a comment AND a field update about the same thing?” → Use multi-action (one agent).
Use calculated fields to extend what agents can see:
Agents cannot access workload metrics, capacity data, or perform reliable arithmetic. But agents CAN read calculated/formula fields. Create a formula that computes the value you need (e.g., available capacity, overdue percentage, risk score), and the agent can read the result and act on it.
-
Behavioural:
-
Non-deterministic behaviour: AI agents may give slightly different responses to the same situation - this is expected for AI.
-
Context boundaries: Agents can only access and work with information within their assigned scope.
-
Language processing: Agents perform best when you provide clear, descriptive text. Agents respect the language used in the instruction for their output.
-
Math/arithmetic unreliability - Agents are unreliable at arithmetic, counting, and multi-step calculations. Use formula fields and automations for calculation-heavy workflows. Agents are excellent at reading calculated values and deciding what to do based on them.
-
Similarly-named items: Agents can confuse siblings with similar names (e.g., “Gate1” vs “Gate2”). Split similarly-named items into separate actions.
-
Actions agents cannot perform:
-
Create new tasks or projects
-
Delete items
-
Change task/project descriptions
-
Execute actions with dependencies - multi-action agents run all actions independently. For dependent workflows, use agent chaining (see Optimization Tips).
-
Send notifications outside Wrike (email, Slack, Teams)
-
-
Data agents cannot access:
-
User profile attributes - agents see user ID and name only (no job role, department, timezone, or country).
-
User group membership - agents cannot see which groups a user belongs to
-
User workload metrics - agents can count assigned tasks but cannot access capacity planning or scheduling data
-
People-type custom fields
-
Attachments (PDFs, images, documents)
-
External data sources (knowledge bases, Google Docs, SharePoint, external APIs)
-
Data outside the assigned scope of space
-
If your agent isn’t responding:
-
Is the agent toggled ON in Space Settings?
-
Has the agent been appointed to a location? Creating an agent is not enough - you must @mention it in the target folder, project, or task.
-
Does the trigger match what actually happened? For example, if the trigger is “Status changed” but the user changed a custom field, the agent won’t fire.
-
For date-based triggers, check that the date field has a value and the trigger timing is correct.
If your agent is making wrong decisions::
-
Check the Activity Dashboard and read the AI reasoning to understand how the agent reached its conclusion.
-
Test in the Playground with the actual item that produced the wrong result.
-
Make your instructions more specific - add explicit rules, examples, and fallback behavior.
-
If the agent confuses similarly-named items (e.g., “Phase 1” vs “Phase 2”), split them into separate actions.
If assignment seems random or wrong
-
Make sure your prompt lists team members by name - agents cannot look up user groups or profile attributes.
-
Check that names are spelled correctly.
-
Include fallback logic for cases where no one matches your criteria.
-
Remember that agents can count assigned tasks but cannot access workload or scheduling data.