Agent configuration and personalization

RevoEngine separates AI configuration into layers so administrators can govern the instance without erasing personal working preferences, while Autonomous Agents keep their own identity, memory, and file boundary.

Configuration is additive, not a permission shortcut. A global plugin, personal preference, memory entry, or workspace file never grants access that the current user or Agent service account does not already have.

Configuration model

Layer	Configured by	Applies to	Examples
Platform safety	RevoEngine and instance policy	Every Interactive and Autonomous Agent execution	Tenant isolation, authentication, approvals, blocked operations, runtime limits
Instance AI settings	Instance Administrator	AI work in the current instance	Global instructions, default plugins, plugin guidance, output ceiling, memory and retention policy, security rules
Personal Interactive Agent preferences	Individual user	That user’s interactive workspace	Reasoning, planning preference, work mode, persona, and custom instructions
Thread or run configuration	User, operator, or automation	One interactive thread, message, or Autonomous Agent run	Selected model, explicit plugins, planning mode, current objective and attachments
Agent definition and policy	Agent operator	Every run of one autonomous Agent	Identity, mission, service account, Agent instructions, plugins, tool permissions, concurrency
Memory and workspace	Runtime and authorized operators	Future work within an exact owner scope	Stable learned knowledge, instruction files, reports, generated code, checkpoints

The current instruction and verified tool results remain authoritative for the task. Imported preferences and memory provide context; they do not override safety, approval, identity, or exact runtime evidence.

Administrator: configure AI for the instance

Open Settings → AI Agents as an Instance Administrator. The workspace is split into four tabs so policy, runtime limits, governance, and usage are not mixed together.

Tab	Configure here
Instructions	Global instructions and default plugins
Runtime	Output ceiling, artifact retention, eager skill loading, and RevoEngine Docs preview
Memory & security	Memory recall and writeback, memory context budget, and tenant security rules
Usage	AI usage for the selected timeframe, comparison with the preceding equal period, and on-demand tool, skill, and plugin activity

Global instructions

Configure global instructions under Settings → AI Agents → Instructions. Global instructions express stable organization-wide expectations, for example:

use the tenant’s approved Components and plugins before ad-hoc alternatives;
preserve backward compatibility for published Endpoints;
redact customer identifiers from user-visible reports;
validate changes in Sandbox before activation;
return an operation identifier for production mutations.

The editor and runtime accept up to 12,000 characters per global instruction entry, preserving paragraphs and lists. Keep the text concise and policy-oriented. Product safety, authorization, approval rules, the current user’s explicit request, and exact execution results still take precedence.

Do not put credentials, private keys, bearer tokens, or Secret values in global instructions. Store them in Secrets and expose only the permitted runtime binding.

Default plugins

Configure default plugins under Settings → AI Agents → Instructions. Select active registry plugins that should be available by default for AI work in the instance. Instance defaults and explicitly selected plugins remain subject to plugin status, capability policy, operation safety, permissions, and approval requirements. A disabled, deleted, unavailable, or policy-blocked plugin cannot become executable merely because it is configured as a default. Default plugin configuration accepts plugin IDs only. Put capability-specific guidance in an approved skill or package plugin. Use global instructions for organization-wide preferences, and keep tool schemas and authentication in the plugin definition. See Plugins for lifecycle, MCP synchronization, safety metadata, and attachment rules.

Runtime output limits

Configure the output ceiling under Settings → AI Agents → Runtime. The administrator can set the maximum output-token ceiling for AI execution from 10,240 to 128,000. This is an upper bound, not a target: individual models, tasks, and runtime policies can use less. Increasing the ceiling can help large code reviews or long structured deliverables, but it also increases latency and cost exposure. Prefer better task scope, references, and artifact workflows before raising it globally.

RevoEngine Docs preview

RevoEngine Docs is an opt-in preview under Settings → AI Agents → Runtime. It lets the Assistant search and read the current public product documentation. Keep it disabled for ordinary RevoEngine implementation work, where the compact product model, Revo skills, current declarations, and authorized instance resources provide a faster path. Enable the preview when users need current official product guidance, design rationale, documented workflows, or citations. Documentation lookup can add several network calls and increase response latency. When the preview is disabled, the Docs tools are absent from discovery, preload, and execution admission. The preview does not prove that a feature is deployed or permitted in the current instance. Exact contracts, permissions, and resource state still come from current platform tools. Public documentation queries must not contain private source code, records, identifiers, or credentials.

Memory policy

Configure memory under Settings → AI Agents → Memory & security. The tenant policy controls whether runtime recall is enabled, whether Agents can persist governed updates, and how much combined digest context can be supplied.

Setting	Meaning	Guidance
Memory enabled	Allows governed memory search and recall	Disable when the tenant must not reuse learned context across sessions
Memory writeback	Allows supported runtimes to persist stable learned context	Enable only when operators accept durable Agent learning and review its results
Context budget	Maximum combined `USER`, `AGENT`, and `WORKSPACE` digest context, from 1,000 to 10,000 tokens	Keep it bounded; use search for deeper recall instead of loading all history

Memory is selective. RevoEngine does not convert every answer, tool output, or conversation into durable memory. See Memory and workspaces.

Storage retention

Instance AI settings also define default retention for private database exports and Agent-created artifacts. Both accept 1–3,650 days. Expiration archives the file first; permanent removal remains governed by the instance garbage-collection policy. Use shorter retention for reproducible temporary exports and longer retention only when the artifact is required as durable operational evidence. An Agent can still select a more appropriate explicit lifecycle when policy and the Storage contract allow it.

AI security rules

Configure security guidance under Settings → AI Agents → Memory & security. Administrators can provide up to 8,000 characters of security guidance, selection terms, and blocked runtime tool names. Use this layer for tenant-wide restrictions such as credentials, customer data, regulated records, or forbidden external mutations. Security guidance complements—not replaces—roles, ACLs, service-account permissions, plugin safety metadata, and approval classification. Test both an allowed and a denied example after changing this configuration.

User: configure personal Interactive Agent defaults

Open Settings → Assistant. This is the current UI label for personal Interactive Agent preferences. These settings belong to the signed-in human account and shape new messages; they do not redefine an Autonomous Agent. The workspace has Defaults, Instructions and Memory tabs with one Save action. Defaults control the response preferences below; Instructions holds personal guidance; Memory lets you inspect, replace or clear your own durable memory text. Memory is context, not an access grant or a replacement for the current request. See 1.5.0 for the expanded personal AI workspace.

Preference	Available behavior
Show progress	Shows intermediate Assistant activity; enabled by default when unset. It does not change reasoning effort, validation, or safety policy
Reasoning	`None`, `Low`, `Medium`, `High`, or `Extra high` as the default effort for new messages
Planner	`Standard` or `Review required`; the latter pauses after planning for an explicit review action
Work mode	`Balanced`, `Coding`, `Business`, `Analyst`, `Operator`, or `Creative`
Persona	Default, Friendly, Pragmatic, Professional, Concise, Calm, Mentor, or Assertive
Custom instructions	Up to 2,000 characters of account-level response guidance

Personal custom instructions are useful for stable preferences:

Lead with the result. For production changes, include validation and rollback.
Use English code identifiers but explain business impact in Polish.

Do not use personal preferences for project facts, passwords, one-off task requirements, or tenant-wide policy. Put the current requirement in the message, stable project context in scoped memory or workspace guidance, and organization-wide rules in instance settings.

Per-turn overrides

The composer can override model, reasoning, planner behavior, permission level, or plugin selection for the current work. A per-turn choice changes that execution context without rewriting the saved account default. Permission choices are Restricted, Auto Review, and Full Access. Work mode, persona, and custom instructions remain account-level response preferences until changed in Settings → Assistant. For example, keep Medium + Standard + Auto Review + Balanced as a daily default, then select High + Review required + Restricted + Coding for a risky cross-Component migration.

Agent: define durable behavior

An autonomous Agent adds another stable layer that personal Assistant preferences do not provide:

a named identity, mission, responsibilities, operating principles, and success criteria;
a least-privilege service account used for runtime authorization;
Agent instructions, model, reasoning, planning, and execution mode;
Agent-owned and policy-managed plugin attachments;
default and per-tool permission policy;
concurrency, child-run, retry, inbox, and trigger behavior;
scoped Agent memory and a governed workspace root.

The Agent definition is stable configuration. Memory, a workspace file, or a session checkpoint cannot silently rewrite its identity or mission. Update the definition deliberately and preserve the version and activity evidence. See Agent configuration for every field and Autonomous Agents for the operational lifecycle.

Memory: bounded learned context, not conversation history

Use memory only for concise information that should remain useful after the current thread or run:

Scope	Example
`USER`	“Prefer concise release summaries with validation first.”
`AGENT`	“This Agent validates ledger totals against the settlement View.”
`WORKSPACE`	“Reports in this workspace use the approved quarterly template.”

The runtime supplies at most one current digest for each active owner scope. Memory use remains bounded by scope, access, and instance policy. Do not store secrets, full documents, transient progress, raw tool output, or reasoning in memory. Store exact content in Storage and keep only a concise convention or reference in memory.

Workspace: the Agent’s durable filesystem

Every successfully created Agent receives a managed workspace or can be linked to an authorized existing Storage folder. The linked root is an enforced boundary:

listing, recursive name search, bounded reads, folder creation, upload, and artifact writes stay inside the root;
the workspace root itself cannot be mutated by the Agent;
another Agent’s managed root cannot be attached as an ordinary shared folder;
ordinary Explorer writes outside the root retain their normal permission and approval policy;
downloads and administrative workspace operations still require authenticated Agent access.

Agents can use authorized guidance and files within the workspace root. Keep operator guidance concise, clearly named, and close to the work it governs; keep large reference material in separate files so it can be reviewed and maintained independently.

Organize concurrent work

Use a predictable structure when an Agent delegates or resumes work:

runs/<agentRunId>/        run-private notes and intermediate artifacts
shared/                   outputs intentionally shared between runs
AGENTS.md                 durable workspace guidance
deliverables/             reviewed final artifacts

Run lineage, inbox state, and session checkpoints coordinate execution. Workspace files are for durable content; memory is not a queue or distributed lock.

Example enterprise setup

Set the tenant baseline

Add global engineering and data-handling instructions, attach the approved CRM and billing plugins, configure memory and artifact retention, and block prohibited external tools.

Let users personalize presentation

Each engineer selects a work mode, persona, default reasoning level, planner behavior, and concise custom instructions without changing tenant governance.

Create a reconciliation Agent

Assign a finance service account, define the reconciliation mission, attach only finance capabilities, and start with review-required mutations.

Use scoped state

Keep stable ledger conventions in Agent or Workspace memory, source files and reports in the Agent workspace, and active progress in the durable run checkpoint.

Validate the boundaries

Run one allowed read, one approval-gated write, one blocked operation, one memory recall, and one workspace artifact flow. Inspect the same run in Activity and Trace.

Governance checklist

Keep global instructions stable, short, and tenant-specific.
Attach only active, reviewed default plugins.
Treat plugin defaults as capability availability, not authorization.
Keep personal preferences out of organization-wide policy.
Use a dedicated service account for every production Agent responsibility.
Store knowledge in memory and exact files in the workspace.
Define retention for memory, exports, and Agent-created artifacts.
Test allowed, approval-required, and denied operations after policy changes.
Review Agent workspace ACLs before linking an existing folder.
Correlate changes and runs through Activity, Trace, and durable execution history.

Interactive Agents

Work in supervised, persistent threads.