Core Capabilities

Siliqun Rotor provides four core capabilities designed to work together on a single customer request:

Connect your existing business systems and APIs (REST-to-MCP).
Allow agents to execute checked rules and access private engine capabilities without open endpoints (Z-Script).
Coordinate multi-agent tasks and hand the result directly to customers (Agent Coordination & Interaction).
Present working, native interactive controls (tables, charts, choices) that resume the exact same run on every action (MVG).

Capability	The Customer Benefit	Nearest Outside Offering	What Siliqun Rotor Does Differently
REST-to-MCP	Your existing business APIs become agent tools that only run after a decision, with consent and a confirmation for every write.	AWS AgentCore OpenAPI-to-MCP Gateway	A typed decision (`decided`, `ask`, `refused`, `unresolved`) sits in front of every API call; writes require explicit confirmation with an idempotency key; per-tool consent; runs on CPU without requiring an LLM.
MVG	Agents answer with working controls (choices, tables, charts) your app renders natively, and each click returns to the same run.	Google A2UI (v0.9.1 / v1.0)	Every event carries `run_id`, `render_id`, `state_version`, and a per-render `sequence`; user interactions resume that run and reject stale state or replays; selections are validated against pending asks before execution; renders without a model.
Z-Script	Agents can use your private engine capabilities through small checked scripts, never through an open endpoint.	Unconstrained code interpreters / Open REST endpoints	Deterministic Lisp subset without I/O, clock, randomness, or environment variables; calls a strict versioned allowlist with bounded fuel, depth, and tenant scoping; writes require confirmation; never exposed over open HTTP.
Agent Coordination & Interaction	Agents coordinate a job between them, and hand your customer the result as an interface they can act on.	Monolithic agent frameworks / Chat-only interfaces	Today: multi-step flows whose every step is traced and can stop for the person's answer, and each hosted project is served as an A2A 1.0 agent (an unsigned Agent Card; a decided read is carried out, an action is only proposed). Agent-to-customer interaction bridges agents directly to human customers via interactive MVG controls with full evidence and audit tracing.

How the Capabilities Compose on a Single Request

When a customer submits a request in an enterprise application:

Customer Request (Agent-to-Customer Interaction)
        │
        ▼
   Siliqun Rotor engine (Decides which action to propose or ask)
        │
   ┌────┴───────────────────────────┐
   │                                │
   ▼                                ▼
REST-to-MCP Tool Binding        Z-Script Guard / Resolver
(Business API with consent)     (Deterministic rule check)
   │                                │
   └────┬───────────────────────────┘
        ▼
Multi-Agent Coordination (A2A)
(Steps of the same flow)
        │
        ▼
Interactive MVG Output (Agent-to-Customer Interaction)
(Chart / Table / Choice UI rendered natively)
        │
        ▼
Customer Action Resumes the Same Run
(Authenticated event with run_id, state_version, sequence)

Agent-to-Customer Interaction: A customer makes a request in your application.
Decision & Routing: Siliqun Rotor evaluates the question against declared tools imported from your OpenAPI specs (REST-to-MCP).
Execution & Guards: Business rules, argument resolvers, and policy constraints run in hermetic Z-Script.
Agent Collaboration (A2A): Multi-step operations run as steps of one flow, each recorded in the run's trace.
Interactive Delivery (MVG): The agent responds with native UI instructions (data tables, bar charts, choice buttons) instead of unstructured prose.
State Resumption: Customer clicks on a bar, row, or choice button emit typed events that resume the exact same run context.