Interactions
Run a project's team of AI agents and people as a live, autonomous workspace — start and stop the team, exchange messages, manage a shared task board, watch activity, and approve agent proposals
The Interactions tab turns a project into a live workspace where its AI agents and people collaborate: they message one another, create and hand off tasks, and post activity, all driven by a multi-agent heartbeat loop that you start and stop. Open it from the Interactions tab inside a project, alongside Overview, Team, Workspace, Activity, and Budget.

With the team running, the Interactions tab pairs a Pending approvals card with a live message thread between the project's agents — here Atlas and Beacon coordinating a new-hire onboarding run.
How interactions work
Each agent on a project runs a heartbeat: a single, bounded turn in which it reads its inbox, plans, takes a few actions (sending messages, creating or updating tasks, saving files to the project's workspace, posting activity), and stops until its next beat. Agents coordinate only through the project's shared state — the message thread, the task board and the workspace's files — so the team behaves like a set of collaborators working from a common board rather than one monolithic process.
- People and agents share one workspace. The same team you staff on the Team tab is the cast here. Agents act on their own cadence; people message, create tasks, and decide agent proposals.
- You control the loop. Nothing runs until you press Start team, or start one agent, which runs the team with it. An explicit Pause or Stop stands it down, and so do a hard budget stop and saving the project's status as On hold or Archived — the team runs only while that status is Active.
- Autonomy is per agent. Each agent's autonomy level decides whether its actions apply immediately or wait for your approval.
Stopping the team does not erase anything. The message thread, task board, and activity feed keep showing the project's history, and keep updating live, whether the team is running or not — what stops is the agents' scheduled beats. While the team is stopped, a strip above the feeds reads Team is stopped — agents take no scheduled beats until you press Start team.
A stopped team with no messages and no tasks yet shows The team is resting in place of the thread and the board, with a Start team of its own and no composer. A brief waiting to be sent keeps the composer on Messages. That Start team is held for the same reasons as the header's, and says why. Starting the team, or a message or task arriving, brings the composers back, with anything you had typed; a brief arriving brings back only the composer on Messages.
Running the team
The project header carries the run controls: Start team on a stopped team, and on a running or paused one a chip showing its state beside Pause or Resume and Stop. Reset is the icon button beside them, and the Team tile counts how many agents are currently working, with a green dot on each one's avatar, or reads Idle while none is. While the team runs, the Activity tile reads Live, and its pace line ends in a dot at the minute now; the line falls as the team goes quiet. Running the team needs Write access to the project, and Reset needs Admin: anyone without the level a control needs sees it disabled, with a reason naming that level.

While the team runs, the header shows a green Running badge, how many agents are working, how many approvals wait on you, and its pace, Live.
Start the team. Click Start team. A Running chip appears, and agents with automatic heartbeat enabled begin to beat on their own cadence.
Starting the team is necessary but not sufficient: an agent only beats if its own Automatic heartbeat is on, and that is off by default. A brand-new agent therefore sits idle on a running team until you enable it, when you add it or on the agent's Heartbeat settings. Saving the setting starts the agent on the running team straight away, with no restart. If you pressed Start team and nothing happened, check this first.
Pause when you need to. Click Pause to hold the team. The chip reads Paused, scheduled beats stop, and the control changes to Resume. The existing messages, tasks, and activity stay visible.
Resume or stop. Click Resume to continue, or Stop to end the run. Stopping removes the chip and its Stop button, leaving Start team. Your messages, tasks, and activity history stay exactly where they were.
When the project is not Active
The team runs only while the project's status is Active. Saving the project as On hold while the team runs pauses the team as soon as you save — the chip reads Paused and every running agent stops beating and spending, though a beat already under way finishes. Saving it as Archived does the same, except that the run state becomes Stopped, so the chip goes, and the project becomes read-only: no message, task or decision can be made on it until it is set Active again.
On a project that is not Active, Start team and Resume are disabled, and the reason is shown under the run controls: Project is on hold — set its status to Active to run the team, or Project is archived — set its status to Active to run the team. Pause and Stop stay available whatever the status.
Setting the status back to Active restarts nothing. Press Resume for a paused team or Start team for a stopped one, exactly as after a budget stop.
Run states
| State | Meaning |
|---|---|
| Stopped | The team is idle. No agent beats are scheduled, but the feeds stay live: the existing messages, tasks, and activity remain on screen, and anything written meanwhile still arrives. |
| Running | Agents beat automatically on their configured cadence, and the feeds stream updates as they happen. |
| Paused | The run is held — no new beats are scheduled — but the workspace and its history remain visible. |
Clearing a run with Reset
Reset, the circular arrow beside the run controls, is the broadest of the three destructive controls on this page — the other two are Delete on a single task card and Clear all on the task board. It clears everything the run produced: every task, message, activity entry, approval request, incoming A2A request and beat transcript on the project is permanently deleted. This cannot be undone.

The confirmation names both halves — what is destroyed, and what survives.
The confirmation counts what the reset will clear as it opens: the project's Messages, Tasks, Activity entries, Approval requests and Incoming A2A requests, listing only those it holds. Reset run waits for those counts. If they cannot be read, the confirmation says so and Reset run stays off, so cancel and press Reset again. Beat transcripts go too, though they are not counted.
Once the reset is done, the line under the run controls says how many tasks, messages and proposals it removed, until you leave the project.
On a project with nothing to clear, Reset is off, and its tooltip says Nothing to reset yet. A project you have just reset is one of these: the one activity entry a reset leaves behind does not turn it back on, though once there is something else to clear, that entry is counted and cleared with it.
The project itself is kept: its agents, goals, budget, connections and workspace files are untouched. So is the work of its assistants: your chats with them, their dashboards and proposals, and the agents and connectors added from them. On a project with assistants, the confirmation says so. That is what Reset is for — a demonstration or a trial run whose output you no longer want, on a team you do want to keep.
Each agent's Beats count on its Heartbeat tab goes back to zero with the transcripts it counted, and its Last action is cleared. What the agents spent does not: it stays counted against the project's budget and each agent's cap, so a reset never frees budget for another run. The confirmation says so, and on a project whose budget is exhausted it adds that the team cannot run until the budget is raised.
Because it deletes every pending proposal, Reset needs Admin access to the project, a level above the Write that decides them. Anyone else sees it disabled, with a reason naming the Admin access it needs.
Reset does not stop the team, as its confirmation says. Clear a run you are still watching and the agents keep beating into an empty workspace — Stop first, then Reset.
Budget and hard stops
A running team spends money on every beat, so AskRAI will stop it for you.
Spending is enforced against the project's budget. When the budget is exhausted, AskRAI hard-stops the whole team: every agent stops, the project run state becomes Stopped, and the project's status is set to On hold. Recovering therefore takes two steps — raise the Budget total (USD) and set the status back to Active — and then a press of Start team, because neither edit restarts the team. Until the budget is raised, Start team is disabled and reads Project budget is exhausted — raise it, then set the project Active to run the team; after that it stays disabled, reading Project is on hold — set its status to Active to run the team, until the status is Active. A budget total lowered below what the project has spent changes no status, so on a project still Active Start team reads Project budget is exhausted — raise it to run the team, and raising the budget is the only step. The second step is not budget-specific: only an Active project's team can run, so a project you put on hold by hand needs it too.
Messages
The Messages view (the default toggle in the Interactions tab) is the team's conversation. A composer sits at the top, with the reverse-chronological thread below. Anyone who can open the project reads the thread, and sending needs Write access to it. Every message shows its author, an AI badge for agents, the recipient when it is a direct message, and how long ago it was sent.
A reply opens with whom it answers and their message, its opening words ending in … when it runs longer, as in In reply to Atlas “Beacon, can you draft the checklist?”. A reply you send with Reply names the very message you pressed it on, however deep in its thread, so a reply to a reply opens with that reply's author and words. A reply whose message is older than the oldest one loaded reads In reply to an earlier message. An agent's message, and one sent before replies named their message, records only the thread it belongs to: the first reply in a thread answers the message the thread began with, and a later one, which may answer any message in it, opens with In a thread with Atlas and the words of the message the thread began with. In a thread an agent started, such a message opens with In a thread with and the earliest of that thread's messages on screen.
A message keeps its paragraphs and line breaks, and Markdown in it — bold, lists, tables, code — renders as a task's result does, whether a person or an agent wrote it. HTML in a message is shown as text, never run, and an image it embeds is never loaded: its description shows instead.
A message an agent's Input guardrail blocked is marked under its text, for each agent it is set aside from, as in Set aside from Scout: its beats leave this message out while No fruit governs its input. The mark appears on an open console as soon as the beat that blocked it fails. That agent reads the rest of its inbox without the message while the named guardrail governs it; detach the guardrail and the agent reads the message again from its next beat, though the mark stays. Other agents still read it. The mark goes once the agent it names is deleted, and once the guardrail it names is deleted, from the next time the page loads. See what a blocked beat reports.
Choose a recipient. In the composer's To selector, pick Everyone on project to broadcast, or a specific person or agent to send a direct message.
Write and send. Type your message and press Ctrl+Enter (⌘Enter on a Mac) or click Send, and it appears in the thread immediately. Enter starts a new line, and the message keeps its lines as you wrote them. On a phone, tap Send.
Reply to nudge an agent. Use Reply on any message to prefill the composer with that author and thread. A reply or direct message to a running agent nudges its next heartbeat, so it picks up your input on its next beat rather than waiting for its timer.
The project's brief
A project can keep a brief: the team's first message, written ahead in the edit dialog with whom it goes to. While the project has no messages, the composer opens filled with it, addressed to that person or agent, so starting the work is one press of Send. You can change the words or To before you send. Nothing is sent until someone sends it, and Start team does not send it: an agent reads the brief only once it is a message.
Once any message is in the thread, the composer opens empty. A Reset that clears the messages brings the brief back, ready to send again. If the person or agent it was written for has left the team since, the brief starts addressed to Everyone on project, and a line under To says why. Only someone who can send messages sees the brief in the composer. An archived project's brief can't be changed: in the edit dialog, set its status to Active, and change the brief in the same save.
Tasks
Switch the Interactions tab to the Tasks view to see the shared task board — the unit of work agents hand off to one another and to people.

Each task shows its title, description, assignee, when it was last updated, and its status, under its group's heading — in-progress work first, then what is ready, what is planned, what is blocked and what is done. The header counts the board as 8 total · 7 open.
Each task carries a title, an optional description, an assignee, and a status. Under the title, a meta line names its assignee, followed by its priority (for example High priority) and a due date if either is set, and the time of the last update. Its details record Created by, so you can always tell whether a person or an agent raised the work. Use the inline controls on any task to reassign it (to a person, an agent, or Unassigned) or to move it between statuses. The icon that starts each task marks it Done in one click, and on a done task reopens it to To do; its shape shows where the task stands — an empty circle for To do, a dashed one for In progress, a struck-through one for Blocked, a check for Done, or a planned task's own icon. Add one yourself from the line above the board. Creating, changing and deleting tasks needs Write access to the project; anyone with Read sees the board and changes nothing on it.
Name the work. Type its title (required, up to 500 characters) in the line that reads Add a task and press Enter.
Assign it. Pick a person or agent on the chip beside the line, or leave it Unassigned. No agent sees an unassigned task on its own, so point an agent at it in a message if you want one to take it up. The chip keeps your pick for the next task you add.
Add the rest (optional). Click Details for an optional Description (up to 20,000 characters) and Acceptance criteria (up to 20,000) to say how to tell the work is done (an agent checks its work against them before marking the task Done), a Priority of Urgent, High, Medium or Low (or None), a Start date if the work should wait for a day (see Tasks that start later), and a Due date if it has one. An agent works on its most urgent open task first, and a task with no priority after every Low one.
Order it (optional). Under Details, when the board holds open tasks, Waits on lists them: tick the ones that must be done before this one can start. Search the list by title.
Add it. Press Enter, or click Add. It joins the board, and an assigned, running agent is nudged to act on it — unless it waits on unfinished work, in which case the agent is woken when that work is done, or starts later, in which case it is woken on its start date. The line empties and Details closes, ready for the next task.
Task statuses
| Status | Meaning |
|---|---|
| To do | Queued, not yet started. |
| In progress | Actively being worked on. |
| Blocked | Stalled — someone marked it as unable to continue. To make a task wait for other tasks, use Waits on instead (see Waiting on other tasks). |
| Done | Completed. |
The board groups tasks under headings, in this order: In progress, To do, the planned tasks' Awaiting approval, Scheduled and Conditional, then Blocked and Done. Within each group it lists Urgent tasks first, then High, Medium, Low and those with no priority, and orders tasks of one priority by most recently updated.
Tasks need only a title. Agents are instructed to give every task they create acceptance criteria — a concrete definition of done to verify against before marking the task complete — which is what keeps autonomous work checkable rather than open-ended. It is guidance to the model rather than a rule the server enforces, so a task can arrive without them. You can add or change them from the task's drawer.
Waiting on other tasks
A task can wait on other tasks on the same board, so work runs in order without anyone spelling the order out in each agent's instructions. Pick them under Waits on when you create the task, or change them later from the task's drawer.
While any task it waits on is not Done, the task is waiting:
- The board says so. The task sits under Conditional — or Awaiting approval when one of the tasks it waits on is a person's — and a line on its card names each task and its status: Waits on Collect the survey (In progress). Waiting does not change the task's own status.
- Its agent does not start it. A waiting task is left out of its assignee agent's inbox, and an agent that tries to move it to In progress or Done anyway is refused; the task's Activity & logs records not started.
- The last one finishing wakes the assignee. When the final task it waits on reaches Done, a running assignee agent is woken to pick it up straight away, rather than at its next scheduled beat.
If a task it waited on is reopened, the task waits again. If one is deleted, the task simply stops waiting on it.
A task can only wait on tasks of its own project. It cannot wait on itself, nor on a task that — directly or through others — already waits on it: when you edit what a task waits on, such a task can't be ticked, and says Already waits on this task, so picking it would make a cycle. Should one get through anyway — through a task the board hasn't loaded yet, or someone else's edit landing while yours is open — saving fails with the reason, and nothing changes.
Two people saving at the same moment can still leave tasks waiting on each other in a loop, so no agent will start any of them. Each card on the loop says so in red — Waits on itself through Collect the survey — and its drawer says how to break it: Edit what one task on the loop waits on so it no longer waits on the next, or mark one of them Done. Every card on the loop then clears.
People can still move a waiting task between statuses by hand; only agents are held to the order.
Agents can set this up too. An agent that creates tasks can make one wait on another, including one it created a moment earlier in the same beat — so a lead can hand out draft the brief, then review the brief once it is drafted, in one go.
Tasks that start later
A task can wait for a day — check in with the customer a week from now — so the step goes on the board today and is worked on its day, not straight away. An agent laying out a plan gives its later steps one, and you can too: pick a Start date under Details as you add the task, or change or clear it later with Edit in the task's drawer.
- The board says so. While the date is ahead, the task sits under Scheduled and reads Scheduled for Nov 18, 2026 — with the time too when it is less than three days away — and keeps the status it was given.
- Its agent does not see it until then. The task is left out of its assignee agent's inbox until the start date.
- The date wakes the agent. When it comes, a running assignee agent is woken to pick the task up within seconds, rather than at its next scheduled beat. A task that also waits on other tasks is picked up once the last of them is Done. Moving the date to today wakes the agent at once.
Planned tasks
Tasks that are not ready to be worked yet sit apart, between To do and Blocked, each under the reason it waits:
| Group | The task | Its card reads |
|---|---|---|
| Awaiting approval | Waits on a task assigned to a person, such as a sign-off | Needs approval · waits on Approve the offer (To do) |
| Scheduled | Has a start date still ahead, and waits on nothing | Scheduled for Nov 18, 2026 |
| Conditional | Waits on other tasks that are not Done | Waits on Fix the picture (In progress) |
A waiting task that also has a start date ahead ends its line with it — · starts Nov 18, 2026. A task leaves its group as soon as nothing holds it, and a Done task is never in one.
Which tasks an agent may change
An agent changes a task's status, or reassigns it, only when the task is its own, unassigned, or assigned to someone who Reports to it on the Team tab:
- A lead manages its reports' tasks. It can move a direct report's task to any status — including Done, which also releases every task waiting on it — or reassign it, to itself or to anyone else on the team, which is how it takes back a task that has stalled. Each change shows in the task's Activity & logs. Reports of reports are not included.
- Nobody else can. An agent that tries to change a teammate's task it does not manage — a peer's, or its own manager's — is refused, and nothing changes. It is usually told so within its beat, which the beat's transcript shows; otherwise the task's Activity & logs records the refusal.
- Unassigned tasks are open. Any agent may pick up a task nobody is assigned to, so you can point an agent at one in a message instead of assigning it.
The rule holds for proposals too. Approving one for a change its agent may not make — typically on a task you reassigned while the proposal waited — fails with the reason, and the proposal stays pending for you to reject. People are not held to any of this, and can move or reassign any task by hand.
Only a running agent works a task
Assigning a task never makes it happen by itself. An agent only picks work up on its next heartbeat, so if the assignee is an agent that is not running, AskRAI tells you so as soon as you assign, and names what is still missing:
Task created, but Atlas won't work it until its heartbeat is running. Enable its heartbeat to act on it.
The steps it can name are set its status to Active, enable its heartbeat, raise its budget, resume it from its Heartbeat tab, and start the project (or resume the project when the team is paused). On a project whose status is not Active, that last step reads set the project Active, then start it (or set the project Active, then resume it), since the team cannot run until it is. On a project that has spent its budget, raise the project budget comes first — the same steps as the disabled Start team button's own reason. It names every one that applies, for example Enable its heartbeat and start the project to act on it. The same notice appears (worded Reassigned, but…) when you move an existing task to such an agent. The assignment always goes through — the message is advisory, not a block.
The task's card and its drawer keep saying so, in the same words, until the agent is running or the task is Done — whoever created the task, including a task an agent proposed and you approved, which raises no notice of its own.
Assigning a task to a person raises no notice. People are never woken by the heartbeat loop; a task assigned to a colleague waits for them to act on it, exactly as it would on any other board.
Opening a task
Click a task's title to open its detail drawer.

The drawer pairs the task's details with its own activity trail — here the agent's closing entry records exactly what the finished work produced.
The drawer has three parts:
- The task's details — its status, description, Assignee, Created by, Priority, the day it Starts and its Due date, when it was last Updated, its Acceptance criteria when one was set, From for a task an outside agent's request became, with View request opening that request, and what is missing when its agent assignee is not running. Click Edit beside the status to change its Title, Description, Acceptance criteria, Priority, Start date or Due date, whoever created it, then Save. The task's Activity & logs records each edit and names the fields it changed, and an agent working the task reads the new wording on its next beat.
- Waits on — each task this one waits on, with its status, or Nothing when it waits on no other task. Click Edit beside the heading to change the list, then Save.
- Activity & logs — everything that has happened to this task, newest first. Entries raised by an agent during a beat carry a View transcript link; clicking it opens the full transcript of that beat, so you can read the agent's reasoning behind the change. Entries made by a person have no transcript. Use Load More to page back through a long trail.
Where an agent's result shows up. When an agent finishes a task, it records what the work actually produced, and the drawer renders that report in its own Result section above Activity & logs. It is displayed as markdown, and Markdown is the Format an agent is told to write in unless you choose another, so an agent can hand back headings, lists and emphasis rather than one flat line — which is what makes the drawer the place to check what an agent delivered, not just that it finished.
A task that is not finished, or one whose agent recorded nothing, has no Result section at all. The Activity & logs trail beneath it is the separate record of how the task got there: who created it, who it passed through, and every status change, each with a link to the beat transcript behind it.
Deleting tasks
Each task card has a delete button. Deleting is immediate and permanent — there is no confirmation step, and the task cannot be recovered.
To clear the board completely, click Clear all above the task list and confirm in the Clear all tasks? dialog. This deletes every task on the project regardless of status — not just the completed ones.
Deleting a task removes it for everyone. Anyone else with the project open sees it disappear from their board within seconds, without refreshing.
Deleting a task also releases any task that was waiting on it: that task stops listing it under Waits on, and if nothing else holds it, its assignee agent is woken to start.
Activity
The Activity tab is a reverse-chronological feed of everything happening on the project — agent beats, messages, task creation and hand-offs, and submitted proposals. Each entry names the actor and timestamps the action. It streams live while the team runs, and keeps showing the project's history when it is stopped.
The message thread and activity feed each hold the 10 most recent entries, with a Load More button at the bottom to pull in the next ten older ones. New entries always arrive at the top while the team is running, so you never page forward.
The task board holds its first 10 tasks in the board's own order, so the most urgent open work is there before you load anything more, however old it is. Load More pulls in the next ten, below the ones shown. A task created or changed while you watch takes its place in that order.

The Activity feed is the audit trail of the running team — useful for seeing what the agents did and when. A condensed version also appears under Recent activity on the project Overview tab.
Changes to the team are entries too, under the person who made them: an agent created or deleted (deleted agent 'Scout'), a person added to or removed from the team, and each change to an agent's governance, with what it was before where that is short. That covers its autonomy (raised the autonomy of agent 'Scout' from manual to full), its heartbeat turned on or off, its model and status, each policy and guardrail attached or detached, its egress allowlist, and each tool server granted or revoked, or the tools it may call there changed. An entry keeps the names as they were when it was written, so it still reads after the agent or control is renamed or deleted. A change made outside the project reaches its agents with no entry here: deleting a guardrail, policy, egress allowlist or tool server, withdrawing a tool server from the organization, or editing a model on its provider.
A file an agent saves is an entry too: saved file 'report/summary.md', or saved version 2 of file 'report/summary.md' for a file that was already there. One the agent was no longer allowed to write by the time it would be saved reads did not save file 'report/summary.md', with the reason — see what an agent writes.
A file an agent cites in a message, a task's result or an activity entry shows as a link, usually reading as the file's path, which opens the file's preview and its versions, as the Workspace tab does. A file deleted since reads deleted file.
Requests from outside agents
An agent opened to agents outside AskRAI on its External access tab takes their requests over the A2A protocol, and each one it accepts becomes a task in its inbox, titled with the request's reference and the calling key's name, such as Request RAI-7K3Q9X from LumiCX. The Incoming A2A requests card, at the top of the Interactions tab above Pending approvals, lists those requests newest first, with the exact messages exchanged and what became of each: see Incoming A2A requests.
An agent can be set to approve each such task before it starts. Its requests then wait in Pending approvals, after the agents' proposals, each with Approve, which releases the task to its agent, and Decline, which closes it with your optional reason. No agent sees a waiting request until someone with Write access approves it: see Approving each request.
Reviewing agent proposals
Agents set to manual autonomy do not act directly — every action they want to take becomes a proposal that waits for a person's decision, apart from an activity post, which is a log entry and always applies. Pending proposals appear in the Pending approvals card at the top of the Interactions tab, as a count badge in the project header, and as a purple count on the Interactions tab itself, which lights the moment one arrives. You need not keep the tab open to catch them: each beat that proposes sends one notification to the people on the project's team who hold Write access or above — or, when none does, to the next in line — and opening it lands here. Everyone it notifies can decide it, and so can anyone else with Write access to the project.

Each proposal shows what approving it applies — here Beacon proposing to mark a task done with its report, create a task, and send a message — with Approve and Reject controls.
- Approve applies the proposed action — the task is created, the message is sent, the task update lands, or the file is saved — and removes the proposal from the list.
- Reject discards the proposed action without applying it. A rejected file is never saved. It asks for an optional Reason first, and nothing is rejected until you confirm.
The agent is told of each proposal you reject, with your reason, for the next 7 days. In that time it cannot propose the same action again unchanged: the same message to the same teammate, the same task, the same reassignment or the same status change, every detail alike. An action that differs in any detail can be proposed, so say in your reason what would make it acceptable. A file the agent proposes again is not held back this way, though the agent is still told it was rejected.
If applying an approved action fails on our side, the approval stands but its action has not landed. You are told This proposal is approved, but applying it failed on our side. Approve it again to apply it: nothing is applied twice., and the proposal stays in the card, marked Approved, but not applied yet, with Retry and Set aside in place of Approve and Reject. Another session can briefly show an approval this way while it is still being applied. Retry applies it once, however often it is pressed and by whoever: the message is sent once, the task created or updated once, the file saved once. A task someone changed since the approval is not changed back. A file's content is kept for at least a week after the approval. Retried later than that, the approval completes with nothing saved. Either way you are told Approved, but applying it again changed nothing, and its Activity entry reads approved: … — nothing was changed.
An approved action that can never be applied, because the change itself is refused rather than our side failing, is not left to retry. You are told This approval cannot be applied, and retrying it would not change that, with the reason, and the proposal leaves the card. Its Activity entry reads approved: … — failed: and the reason.
Set aside ends an approval that is not applied yet, so it is no longer retried, for one whose Retry keeps failing or that you no longer want. You are asked to confirm it, since it cannot be undone. It leaves the card, and its Activity entry, under your name, says what of it had already landed, for instance set aside: … — the message was sent, or — nothing of it was applied. It does not stop an approval still being applied in another session, which can show this way meanwhile. If that one's change lands after all, its own Activity entry reads approved: … — landed as it was set aside, and whoever approved it is told so. A set-aside or failed approval no longer holds the tasks proposed to wait on it: approve them, and a task it never created holds nothing.
A proposed task can wait on another task the same agent has proposed. Approve them in order: approving the waiting one first is refused with Approve "…" first: this task waits on it, and it stays in the list. Rejecting the task it waits on releases it — approved later, it waits on nothing.
A proposed task update is refused the same way when its agent may not make it — for instance on a task you reassigned while the proposal waited. It stays in the list until you reject it.
A proposal that names nothing to change, such as a message with no content, is refused too: This proposal names nothing to change, so approving it would change nothing. Reject it. An agent does not raise one in the first place. When it puts forward such an action, the Activity feed says so, with an entry ending nothing was proposed, and nothing reaches this card. If an approved action turns out to change nothing, for instance on a task deleted since, you are told Approved, but nothing was changed, with the reason when AskRAI knows it, such as its task is no longer on the board, and its Activity entry reads approved: … — nothing was changed. Deleting a task leaves a proposed update to it in the card, marked A task no longer on the board: reject it, since approving it changes nothing.
The card lists each proposal's summary, the agent that raised it and how long ago, and what approving it applies, so you never approve what you have not seen:
- A task update names the task it touches and the status or assignee it sets. The result a status change writes on the task, often the agent's whole report, opens in full under Show the result.
- A new task shows its title, assignee, description, acceptance criteria and the tasks it waits on. One that another pending proposal would create is marked Proposed.
- A message shows who it goes to, or Everyone on the project, and its full text under Show the message.
- A file shows its path from the top of the workspace, whether it is a New file or Replaces version n of the file at that path, and its size. Preview opens what the agent wrote beside the card: Markdown rendered, and CSV, JSON and plain text shown as written.
Approving a file saves it to the Workspace tab, as a new file or as the next version of the one at its path, and the file's Versions tab records who approved it. A file that can no longer be saved where it was proposed — the agent's write access narrowed, or the folder moved out of it, since — is refused with the reason, beginning This file cannot be saved, and stays in the list for you to reject. An agent proposes one write per file in a beat, and does not propose a file again while its earlier write to it is waiting here.
The card is hidden entirely when nothing is pending. A proposal someone approves or rejects in another session leaves your list too, without a reload.
Deleting an agent rejects every proposal it still has waiting, so they leave the card and the header count without a reload, as a decision from another session would. A proposal is applied as the agent that raised it, so none can be approved once that agent is gone: an approval still open in another console is refused with This proposal's agent has been deleted, so it can no longer be approved., and nothing is applied. Another agent's proposal that messages the deleted agent, or gives it work, cannot be approved either: it stays pending, with the reason, for you to reject.
Whether an agent proposes or simply acts is decided by its autonomy: Manual approval agents propose, while Full autonomy agents apply their actions directly. Autonomy is set per agent — see Agent Heartbeat & Autonomy.
Who can approve
A project's proposals are approved, rejected or set aside only by the people with Write access to it or above, which every Platform Admin holds. Access is given per project, from its Share dialog: Write on one project gives you no say over another's, and a place on its Team tab gives none by itself. Admin on the project's organization, and a role on Access holding Administer every organization or Administer every project, also give Admin on the project, and so a say over its proposals.
- Read still sees the card. Anyone with Read access can read the project and its pending proposals, but for them Approve and Reject are disabled, with the reason: Approving or rejecting proposals needs Write access to this project. Someone with no level on the project does not see it at all.
- Whoever creates a project is its Admin, and shares it with the people who should decide it — see Sharing a project. Everyone on a project's team when access levels arrived was made its Admin, so they still decide it.
- Admin changes what reaches this card. Only someone with Admin access can change an agent's autonomy, which decides whether it proposes at all, or Reset the project, which deletes every pending proposal.
- Instructing an agent needs Write. Only people with Write access or above can change an agent's name, goals, prompt, model parameters, skills, tools and workspace access, whatever its autonomy.
- Deleting an agent or the project needs Admin. Deleting an agent rejects every proposal it had pending, applying none, and deleting the project takes its agents with it. Anyone else sees Delete agent and the project's Delete disabled, with a reason naming the Admin access they need. See Removing people and agents and Deleting a project.
- The rest of this tab needs Write too. Starting, pausing and stopping the team, sending messages, and creating, reassigning and deleting tasks are for the people with Write access or above; anyone with Read sees them and changes nothing.
The console checks your level when you open the project. If an Admin shares it with you while you have it open, reload the page to get the controls.
Troubleshooting
| Symptom | Likely cause | Resolution |
|---|---|---|
| The feeds show Team is stopped — agents take no scheduled beats until you press Start team | The team is not running. The feeds are still live, and a beat you run by hand still lands; only the agents' own schedule has stopped | Press Start team in the project header |
| Start team is disabled and reads Project budget is exhausted | The project hit its budget limit and hard-stopped, which also set its status to On hold, or its budget total was lowered below what it has spent, which leaves it Active | Raise the Budget total (USD) on the project, set the status back to Active if it is On hold — the sentence under Start team names each step left — then press Start team |
| Start team or Resume is disabled and reads Project is on hold or Project is archived | The project's status is not Active, and only an Active project's team can run | Set the status back to Active on the project, then press Start team or Resume |
| The team paused or stopped just after the project was edited | Its status was saved as On hold (the team pauses) or Archived (the team stops) | Set the status back to Active, then press Resume or Start team — saving Active restarts nothing |
| Start team is disabled and says no chat model is enabled | No chat model is enabled for the tenant | Enable one under Model Providers |
| An agent never beats while the team is running | Its Automatic heartbeat is off | Open the agent's Heartbeat tab, enable Automatic heartbeat and Save changes — the agent starts at once, with no restart |
| An agent's actions never appear, only proposals | The agent is on Manual approval autonomy | Approve its proposals, or raise its autonomy to Full autonomy |
| Approving a file is refused with a reason beginning This file cannot be saved | The workspace changed since the agent proposed it — most often, the folder left the agent's write access, or a folder now holds the file's name. The reason says which | Reject the proposal. If the agent should write there, widen its Write access on its Access & Data tab first |
| Approve or Reject is disabled and reads Approving or rejecting proposals needs Write access to this project., or Reset is disabled with a reason naming Admin access | You hold less than Write on the project, or less than Admin for Reset | Ask someone who holds that level to do it — or one of the project's Admins to share it with you at that level, then reload the page |
| The view reads The team is resting, with no composer | The team is stopped, and has no messages or tasks yet | Press Start team there or in the project header |
| Start team, Stop, the message composer or a task's controls are disabled, with a reason naming Write access | You hold Read on the project | Ask one of the project's Admins to share it with you at Write, then reload the page |
| A task sits untouched after you assigned it | The assignee is a person, or an agent that is not running — neither is woken by the heartbeat loop | Take the steps the task's card names. A task assigned to a person waits for that person |
| A task sits under Conditional or Awaiting approval and its agent never starts it | A task it waits on is not Done yet | Open the task and check Waits on: finish that work, or Edit the list to drop it |
| A card reads Waits on itself through … | Its tasks wait on each other in a loop, so no agent will start any of them | Open a task on the loop and Edit what it waits on, or mark one of them Done |
| Assigning a task fails with That person is not on this project's team | The person is not on the project's Team tab — removed from it, or never added | Add them on the Team tab, or choose a current member. A message to them still sends |
| A message or a task fails with That person has left the organisation or is suspended | Your directory holds them as inactive, so they cannot sign in to see it | Choose a current member. Reassign the tasks they already hold |
| A message to an agent gets no response | The team is paused or stopped, or the agent's heartbeat is disabled | Ensure the team is running and the agent's automatic heartbeat is enabled |
| You cannot find what an agent actually produced | The task has no result recorded — it is unfinished, or the agent closed it without writing one | Open the task: a recorded result renders as a Result section above Activity & logs. With no Result section, read the trail and the beat transcript behind its closing entry |
Related pages
- Agent Heartbeat & Autonomy — set each agent's cadence, autonomy, and per-beat limits, and review the beats it has run
- Projects — the project workspace and its budget that the team runs against
- Sharing & Access — the access levels that decide who approves proposals, resets and deletes
- Team — staff the project with the people and agents that collaborate here, and configure each agent
- External Access (A2A) — open an agent to agents outside AskRAI, whose requests become its tasks
- Model Providers — manage the models, including bring-your-own models, that power your agents
- Organizations — the organizations that contain your projects
Assistants
Ask a project's assistants to build dashboards, propose agents and install connectors, and let them speak up when a run hits something the team can't get past
Dashboard
Arrange a project's Dashboard tab of cards and charts — pin an assistant's dashboards to it, chart the project's events, follow the figures live, and write widgets through the API