Agentic Engine
The Agentic Engine lets you hand a complex, multi-step goal to the AI and have it plan and execute the work autonomously. Instead of a single back-and-forth conversation, you describe what you want, the engine breaks it into tasks, assigns each task to a specialist agent, and works through them in order — asking you questions only when it genuinely cannot proceed without input.
Triggering a Run
Type /agentic followed by a description of your goal in the AI chat:
/agentic Produce a variance analysis report for all European entities comparing Actual vs Budget for Q1 2025, grouped by department
/agentic Review all pending actions assigned to the finance team and generate a status summary
There is also a dry-run mode that plans and resolves agents without executing anything — useful for previewing what a run will do before committing:
/agentic-dry-run Analyse headcount data across all entities and flag anomalies
How It Works
A run goes through six phases in sequence:
1. Clarify Requirements
Before planning begins, the engine checks whether there is a critical piece of missing information that would materially change the plan. If so, it asks you one question at a time (up to 5 rounds) with suggested answer options where applicable. Once the requirements are clear, it proceeds automatically.
The clarifier only asks about things that a capable agent cannot reasonably look up or assume on its own. It will not ask for information that is available in the data.
2. Create a Plan
A planning agent decomposes your goal into an ordered list of tasks. Each task has:
- A short name and a comprehensive description
- An assigned agent owner (the specialist responsible for that task)
- An optional dependency on another task — the task will not start until its dependency completes
The planner aims for the minimum number of tasks needed. Each task is designed to produce exactly one deliverable. If your goal would produce 3 reports, the planner creates 3 separate tasks — not one task that produces all three.
If the plan exceeds 25 tasks, the planner is asked to consolidate before execution begins.
3. Resolve Agents
For each distinct agent name in the plan, the engine looks for a matching agent file:
/Local AI/Agents/<agent-name>.md
/AI/Agents/<agent-name>.md
If a file is found, the agent's model, tools, and system prompt are loaded from it.
If no file is found, the engine creates an ad-hoc agent on the fly: it looks at all tasks assigned to that agent name, synthesises a suitable system prompt and tool list, and proceeds. Ad-hoc agents work for many cases but produce more predictable results when a custom agent file exists.
4. Execute Tasks
Tasks run one at a time in dependency order. A task only starts after its dependency has completed successfully. The chat shows live progress: which step is running, which agent is working on it, and the result when it finishes.
Each task receives:
- Its own description (copied directly from the plan)
- The output of any tasks it depends on (summaries and full file contents)
This means a task that depends on an earlier task automatically has access to everything that task produced.
5. Review the Plan (Adaptive)
After each completed task that has dependents, the engine reviews whether the plan still makes sense given what was just learned. It can:
- Add new tasks if the completed task revealed unexpected work
- Remove tasks that are now redundant
- Update descriptions of pending tasks with new context
Completed tasks are never changed or removed during review — only pending tasks are affected.
6. Final Summary
When all tasks are done (or the run is stopped), the engine posts a summary showing:
- Which tasks completed and which did not
- A one-line result for each task
- Links to all output files produced
- The path to the results folder
What You Can Ask It To Do
The engine works best for goals that:
- Have multiple distinct steps or deliverables
- Benefit from different agents specialising in different parts
- Would take several manual back-and-forth turns to complete
Examples of good goals:
/agentic Pull revenue data for all entities for 2024 and 2025, compute year-over-year
variance, and write a summary report with a recommendations section
/agentic Check if there are any users with no login activity in the last 90 days
and create a report listing them with their assigned groups
/agentic Read the budget file in /Reports/Budget_2025.xlsx, validate the data against
the model, flag discrepancies, and write a validation report
/agentic Design a dashboard for the CFO showing cash flow KPIs, an entity comparison
chart, and a monthly trend table — produce the full dashboard model JSON
Tips for better results:
- Be specific about the output. "Write a report" is good. "Write a Markdown report with an executive summary, a table of results, and a recommendations section" is better.
- Name agents explicitly if you need a specific one. If you have a
report-designeragent file and want to use it, say so: "Use the report-designer agent to produce the specification." - Give context the agents will need. Model names, dimension names, file paths, date ranges, entity names — anything an agent cannot look up on its own should be in your request.
- Use
/agentic-dry-runfirst for complex goals. It shows you the plan and which agents will be used before any work is done.
Cancelling a Run
You can cancel a run at any time using the stop/cancel button in the chat. The engine will complete the current task cleanly, write the final plan state to the work folder, and stop. Any output files already written are preserved.
Where Results Are Saved
All output is written to the Una file system under:
/AI Local/Results/<timestamp>/
The timestamp folder is named YYYYMMDD_HHMMSS (e.g. 20250508_143022). Inside it:
| File / Folder | Contents |
|---|---|
plan.md | The live execution plan — updated after every task. Shows goal, task list with status, agent assignments, and per-task results. |
plan_history.md | Snapshots of the plan at every revision point — useful for understanding how the plan evolved. |
run.log | Timestamped log of every message sent during the run, including agent names and task descriptions. |
<output-file> | Any files produced by agents and marked as final output land directly in the timestamp folder root. |
temp/ | Intermediate files produced by agents that are not final output. These are passed as context to dependent tasks but are not the primary deliverables. |
Output files are linked directly in the chat at the end of the run and after each task that produces one — you can open them from the chat without navigating to the file system manually.
Limits
| Limit | Value |
|---|---|
| Maximum run time | 10 minutes |
| Maximum agents per run | 10 |
| Maximum tasks per plan | 25 |
| Clarification rounds | 5 |
If the 10-minute limit is reached mid-run, the engine stops cleanly, writes the final plan state, and posts a summary of what completed. Tasks that did not run are listed as incomplete in plan.md.
Agents and Ad-Hoc Agents
The engine works whether or not you have custom agent files. If you do not have any agents defined, it creates ad-hoc agents automatically based on the tasks assigned to each agent name.
Custom agent files (placed in /Local AI/Agents/) give you control over:
- The exact model each agent uses
- Which tools it has access to
- Its system prompt — domain knowledge, output format requirements, terminology
For work you run repeatedly (e.g. a report-designer agent, a data-validator agent), defining agent files produces more consistent results than relying on ad-hoc generation each time.
See docs/una-agents-guide.md for how to create agent files.
The Plan File
plan.md in the results folder is a live document that reflects the state of the run. It is a useful reference during and after the run:
# Goal
Produce a quarterly variance report for EMEA entities.
**Progress:** 3/5 (60%)
## Tasks
| # | Status | Name | Agent | Depends On |
|---|:------:|-------------------|-----------------|:----------:|
| 1 | ✓ | Fetch entity data | DataAgent | — |
| 2 | ✓ | Compute variance | AnalysisAgent | 1 |
| 3 | ✓ | Write report | WriterAgent | 2 |
| 4 | ☐ | Validate output | DataAgent | 3 |
| 5 | ☐ | Final summary | — | 4 |
Each task section also shows the full description, the agent that ran it, its result summary, and links to any output files it produced.