Where the Interactive Agent is strong
The Interactive Agent is designed for platform-aware engineering and operations work: it can connect an intent to the exact RevoEngine objects, their selected versions, dependencies, execution evidence, and governed change path. That is a materially different capability from a general-purpose chat model with only pasted context. It is especially effective for:- impact analysis before changing a shared Component, library, Endpoint, or schema;
- tracing a failed Job, Event, webhook, Endpoint execution, or Agent run from durable evidence;
- agentic coding against versioned low-code and custom Node.js application definitions;
- producing a plan, validation sequence, and rollback boundary before a production mutation;
- using permitted platform and plugin capabilities without handing credentials to a model prompt.
Capability and access boundary
The Interactive Agent can have broad access to your authorized platform surface, but it never receives blanket administrator access because it is AI-driven. Every turn is constrained by the current identity, thread configuration, instance policy, enabled capabilities, target ACLs, and approval policy.
It cannot reveal Secret values merely by being asked, bypass role checks or tenant isolation, access private RevoEngine control-plane implementation, run host shell commands without an approved connected terminal, or silently perform a blocked, destructive, or external change. A capability shown in the activity timeline is evidence of a governed attempt, not proof of unlimited access.
For terminal work, follow Connect a terminal. For broader coding workflows, compare RevoEngine and coding agents.
Start a productive thread
1
State the outcome
Describe what should be true when the work is complete. Include constraints such as environment, compatibility requirements, or whether you want explanation only.
2
Reference the target
Mention a platform object from the composer when possible. A direct reference is safer than relying on a similar display name.
3
Choose how the Assistant should work
Select the model, reasoning effort, planning policy, and permission level appropriate for the task. Attach only the plugins needed for this thread.
4
Follow the execution timeline
Watch searches, reads, validation, plan progress, and approval requests. Open a completed activity to inspect its persisted details.
5
Verify the outcome
Ask the Assistant to run the relevant validation or inspect the updated object. A written claim is not a substitute for a successful check.
Threads are the unit of work
A thread preserves the visible conversation and the runtime state needed to continue safely. You can:- rename, search, delete, and restore threads;
- organize threads in personal, instance-scoped groups, move them between groups, and collapse groups while browsing the history;
- continue a completed thread with new instructions;
- refine the requested outcome through follow-up messages and reviewable execution plans;
- share a read-only thread view;
- fork from a selected message to explore another direction without rewriting the source thread;
- inspect message-level execution details and retained artifacts.
Charts, diagrams and tables in answers
Ask the Assistant to show a chart, diagram, table, comparison or visual analysis. It can return one analytical card that combines explanatory text, a Mermaid diagram, AG Charts plots and an interactive AG Grid table. You do not need to request or create a dashboard. The Assistant makes an authorized, bounded read when it needs instance data, validates the result, and attaches the complete card to the conversation. Its final message contains an interpretation; it does not need to repeat thousands of rows. The card uses the same Custom Widget cell renderer as dashboards. Expand the complete card for a wide chart or table. Code opens the JavaScript or TypeScript that produced it in Monaco; Copy copies the displayed matrix. The answer is a snapshot. Convert to dashboard is a separate user action for creating a dashboard or adding the widget to an existing one. Review the source and inputs before choosing a dynamic widget; a fixed snapshot preserves the displayed result. Saving follows dashboard permissions. See Dashboards.Result structure
The executable function body returns a nonempty matrix: an array of rows, with one to four cells per row. Alternatively, return{ matrix, summary }; calculate the short summary from the same data that produced the card. Cells may use width (percentage, greater than 0 and at most 100) and height (80–800 pixels). Width and height belong to the cell, not to AG Charts options.
The generated card accepts up to 8 rows, 4 cells per row, 5000 flat records per CHART or TABLE, 16 chart series, 12 table columns and 2 MB for the entire serialized matrix. Data field values can be strings, finite numbers, booleans or null; nested objects, arrays, JavaScript callbacks, Date objects, NaN and Infinity are not valid data field values. Keep individual strings below 4000 characters. Aggregate a larger source before returning it, identify the population and period, and say when a cap makes the result partial. A format failure prevents publication; a successful tool receipt confirms validation and persistence, not that the browser has rendered a chart.
Tables: exact column contract
Each table column is{ field, headerName, type }. The accepted types for a generated answer are TEXT, NUMBER, DATE, and BOOLEAN. Additional column properties are discarded. Although the dashboard table component has an internal JSON type, the Assistant’s generated-widget contract does not accept it.
TEXTis escaped before it reaches AG Grid. HTML and Revo ref tokens stay plain text in a cell; place clickable reference tokens in aTEXTcell above or below the table.NUMBERuses local numeric formatting. Supply actual numeric values rather than strings containing currency signs or separators. Put units in the heading or column label.DATEaccepts an ISO date string or epoch value, parses it and displays the UTCYYYY-MM-DDdate. Invalid dates display as null.BOOLEANshould be a realtrueorfalse; a string such as'false'is truthy and would display incorrectly.- Null values use the table’s null placeholder. This card does not accept custom AG Grid renderers, JavaScript value getters, column callbacks, server-side row models, grid state or arbitrary
ColDefoptions.
data: [] with valid columns and a TEXT cell stating the queried scope. A failed query should be corrected or reported, never represented as a fabricated empty table.
Charts: what this version accepts
Revo uses AG Charts 13.2.1 Enterprise, and the Assistant’s generated card accepts these fifteen series types. Each key names a field in the flatdata rows.
For a mixed Cartesian chart, put compatible
bar, line, area, scatter or bubble series in the same options.series array. When measures have different units, set yKeyAxis: 'rateAxis' on the percentage series and define axes: { y: { type: 'number', position: 'left' }, rateAxis: { type: 'number', position: 'right', min: 0, max: 100 } }. Give both series meaningful yName labels and state the units in an adjacent TEXT cell. Use separate CHART cells for unrelated standalone plots such as a funnel and a donut.
A gauge is a special CHART cell with data: [] and options: { type: 'radial-gauge' | 'linear-gauge', value, scale: { min, max } }. It has no series or legend. Value and optional targets: [{ value, text }] must be finite and within the scale; min must be smaller than max. A radial gauge is compact for a single KPI; a linear gauge is useful for comparing progress with a threshold. Put the unit, timeframe and denominator in TEXT. Other AG Charts families such as financial series, radar, treemaps, maps and flows are not accepted from generated cards today.
Within the accepted series types, AG Charts JSON options may set a title, legend, axes, zoom and navigator. A continuous number axis may use axes: { y: { type: 'number', min: 0, max: 100 } }; preferredMin and preferredMax leave room for data beyond a preferred range. Use numeric epoch milliseconds for flat time-series data when selecting a time axis. zoom: { enabled: true } and an initial zoom range or ratio can focus a dense plot. A fixed or cropped axis changes the visual impression, so state the range and aggregation in accompanying text. Avoid opaque chart backgrounds: the Revo wrapper already supplies the active theme and a transparent background.
Set legend: { enabled: true, position: 'right', toggleSeries: true } to show a clickable legend on the right. position accepts top, bottom, left or right and their corner variants; it can also be an object with placement and floating. Set enabled: false to hide it. When legend is omitted, the shared chart wrapper supplies a bottom legend for charts with multiple series and for single pie, donut or waterfall series, including after conversion to a dashboard. An explicit setting takes precedence. Name series with yName or legendItemName, and pie/donut categories with calloutLabelKey; a legend without meaningful labels is hard to interpret. Legend configuration accepts JSON settings, not formatters or event callbacks.
Chart options must remain JSON. Callback formatters, event handlers, custom tooltip functions, stylers and Date instances cannot pass through this artifact. Precompute labels and values in the returned data. The backend checks supported series, required keys and field presence, but browser rendering still depends on a valid AG Charts combination. Keep the option tree simple and correct validation errors before claiming success.
Complete example: text, chart and table together
This JavaScript function body returns a single card. It computes the summary from the same values shown in the chart and table. Replace the sample rows with an authorized, bounded read for real instance data.Mixed chart, gauges and exact rows in one card
This CODE_JS function body combines a dual-axis comparison, two gauges and an AG Grid table. The chart and table share the same records; the gauges use the latest row. Replace the sample with an authorized bounded read for live data.Additional patterns
Distribution. Fordata: [{ latency: 110 }, { latency: 160 }], use options: { series: [{ type: 'histogram', xKey: 'latency', bins: [[0, 100], [100, 200]] }] }. Add a TEXT cell naming the latency unit and population.
Share. For data: [{ name: 'A', count: 12 }, { name: 'B', count: 8 }], use options: { series: [{ type: 'donut', angleKey: 'count', calloutLabelKey: 'name' }] }. A precise table may be clearer when there are many categories.
Range and heatmap. For data: [{ week: 'W1', low: 10, high: 18 }], use series: [{ type: 'range-area', xKey: 'week', yLowKey: 'low', yHighKey: 'high' }]. A range-bar uses the same keys for separate intervals. For data: [{ day: 'Mon', team: 'A', load: 0.7 }], use series: [{ type: 'heatmap', xKey: 'day', yKey: 'team', colorKey: 'load', colorRange: ['#e2e8f0', '#1d4ed8'] }] and explain the color scale in TEXT.
Waterfall. For data: [{ step: 'Start', delta: 20 }, { step: 'Refunds', delta: -5 }], use series: [{ type: 'waterfall', xKey: 'step', yKey: 'delta' }]. Add a table for exact signed values.
Box plot. For data: [{ cohort: 'A', min: 2, q1: 4, median: 6, q3: 8, max: 12 }], use series: [{ type: 'box-plot', xKey: 'cohort', minKey: 'min', q1Key: 'q1', medianKey: 'median', q3Key: 'q3', maxKey: 'max' }]. Compute quantiles from real samples and state each cohort’s sample size.
Stage analysis. For data: [{ stage: 'Visited', value: 100 }, { stage: 'Qualified', value: 42 }], use series: [{ type: 'funnel', stageKey: 'stage', valueKey: 'value' }]. A pyramid uses the same keys for stage magnitude. Add a table for exact counts and conversion rates.
Diagram and analysis. Return a TEXT cell containing a Markdown heading, a fenced mermaid diagram and a short interpretation. The text renderer draws Mermaid after the message completes. Put exact Revo reference tokens in an adjacent TEXT cell, outside the Mermaid fence; add a TABLE or CHART row when the diagram has supporting measurements. Derive nodes and edges from the relevant resource, dependency or execution evidence, rather than inventing a flow.
Source and saving. The complete validated matrix stays with the conversation; the Assistant receives a compact receipt with cell counts, summary and diagnostics. The user may inspect the code, expand the card and explicitly convert it to a dashboard. A dynamic dashboard widget runs its original inline code and inputs on load or refresh; a fixed snapshot retains the displayed matrix. See Custom widgets in dashboards for execution and refresh settings.
Progress and files
Show progress controls intermediate activity in the conversation and defaults to enabled when no preference has been saved. It does not change reasoning effort or approval policy. Revised plans use your feedback without requiring the same wording; review-required plans still wait for approval. New files created by the interactive Assistant default to Private. Updating a selected existing file follows its current access rules. Autonomous Agents keep their own workspace default. The Assistant can read and attach files from other workspaces when its execution identity has access; a workspace name alone does not grant permission. A successful Chat send confirms the message and its attachments in Chat. Email notification delivery is tracked separately and follows the recipient’s settings. The Assistant must not report email receipt merely because a Chat message was created.Give the Assistant concrete context
Platform references
Use the reference picker to attach the exact component, endpoint, database, Agent, job, file, or other supported platform object. The runtime can then inspect current details and, where available, historical versions or dependencies.Images
The composer supports PNG, JPEG, and WebP images up to 10 MB each. Images are uploaded to a draft message before send, so an interrupted upload does not publish a partial user message.Plugins
Attach registry plugins when the task needs tenant-specific or external capabilities. Attached plugin IDs remain associated with the thread and are still filtered by status, policy, and tool-level safety rules.Models and reasoning
The models available to the Assistant are controlled by the current RevoEngine release and instance configuration. Public reasoning levels are Low, Medium, High, and Extra high.Current model support
Select Fast Mode for either GPT-6 model when lower response latency matters for the current conversation. Standard remains the normal path when Fast Mode is not selected. Autonomous Agent runs use Standard processing. Existing active GPT-5.6 Sol choices migrate to GPT-6 Sol; Terra and Luna choices migrate to GPT-6 Luna. Historical messages and usage keep their actual model identity.
Use lower effort for direct questions, small edits, and well-scoped reads. Use higher effort for cross-object changes, ambiguous architecture decisions, incident analysis, and review-required plans. Availability and defaults can vary by instance configuration.
Permission levels
Choose the permission level for the task from the Assistant composer:
For most well-scoped implementation and operations tasks, Auto Review provides a practical balance between progress and supervision. Use Restricted when you need to inspect every material action. Reserve Full Access for trusted workflows whose scope and access are already tightly controlled.
See Approvals and plans for how Auto Review handles side effects and multi-step work.
Streaming, background work, and follow-ups
Assistant turns stream messages, progress, tool activity, and action-required events as they happen. When background processing is enabled, the server can continue a persisted turn after the client disconnects; reopening the thread hydrates the current durable state. If you send another message while a turn is active, the UI can queue it for later or use it to steer the current work. Steering is a correction to the active task, not a new independent thread. When the Assistant asks for clarification, you can choose an offered answer or write your own correction. Independent questions can appear together in one request. If your decision depends on an explanation, say so: submitting that response does not approve a proposed change or close the underlying decision. Passwords requested for a connected browser use a separate secure dialog.What you can inspect
The execution timeline can include:
Reasoning can be presented as concise summaries and progress—not private chain-of-thought. Secrets and private platform implementation are not included in shared thread output.
Capabilities in practice
Typical read capabilities include platform and code search, contract inspection, version comparison, dependency analysis, operations investigation, conversation retrieval, and approved web research. Governed action capabilities include bounded validation, Platform changes, Storage operations, plugin actions, messaging, memory, and Agent handoff. Availability is determined by the current identity, target ACL, instance configuration, Agent or thread policy, and approval requirements. Read Tools and skills for the public capability families and examples of requests that keep work bounded.Example requests
Assistant and regular chat
The Assistant surface is separate from user and group chat. Regular chat manages conversations between people and system notifications; it does not automatically execute the Assistant tool loop.Configuration and personalization
Understand instance defaults, personal preferences, memory, and Agent workspaces.
Agentic coding
Follow the evidence-first coding workflow.
Approvals and plans
Configure how supervised actions pause and resume.