Skip to content

Generative UI

NetOrca Pack can optionally render an AI Processor response as a rich user interface instead of showing only raw markdown or JSON. This is useful when the AI response is intended to be read directly by users in the GUI, for example as a structured review summary, a table of findings, a metric card.

When this feature is enabled, the AI Processor is expected to return a Generative UI JSON response. NetOrca will then render the response using a fixed set of supported component types.

How it works

There are two steps of configurations for this feature:

  1. Generative UI Catalog Schema in AI Integration general settings managed by NetOrca administrators.
  2. Enable generative UI on the individual AI Processor managed by Service Owners.

The Generative UI Catalog Schema defines the supported component types and the structure the AI response should follow. The AI Processor then uses this schema as its response format when generative UI is enabled.

The current implementation is intentionally controlled:

  • the AI must return JSON
  • the JSON must follow the expected Generative UI component format
  • the frontend only renders supported component types
  • if the response is not valid Generative UI JSON, NetOrca falls back to the normal response renderer

How to configure it

1. Configure the catalog schema

The Generative UI Catalog Schema is configured by administrators in Platform Settings → General Settings.

That setting defines which component types are allowed and what fields they require.

2. Enable it on an AI Processor

When creating or editing an AI Processor, enable:

  • Enable generative UI

This tells NetOrca to expect a Generative UI response for that processor.

3. Provide a suitable prompt

Your AI Processor prompt should clearly instruct the model to return structured JSON that matches the configured Generative UI component schema.

For example, instead of asking for a free-form paragraph, you might ask the model to return:

  • a title and a summary text block
  • a table of findings with pre-defined columns
  • an alert when a critical issue is found

4. (Optional) Deterministic UI

You can optionally define a Response JSON Schema directly on the AI Processor. If not defined, the schema is taken from the Generative UI Catalog Schema configured in General Settings.

If a Response JSON Schema is defined on the AI Processor, it overrides the catalog schema for that processor.

This is useful for deterministic responses: when no schema is defined here (i.e. the catalog schema is used), the LLM decides which components to return and in what order. By defining a schema on the processor, you fix the exact UI layout you want — the LLM will only fill in the data inside the predefined components.

The deterministic schema is structured as a JSON object where the top-level keys are numbers starting from "0", defining the order in which components are rendered. The value of each numbered key is a component schema taken from the component types available in the Generative UI Catalog Schema (configured in General Settings). You can pick any component from the catalog and place it at the position you want.

For example, a deterministic Response JSON Schema might look like this:

{
   "type":"object",
   "required":["0"],
   "properties":{
      "0":{
         "type":"object",
         "required":["type", "title", "components"],
         "properties":{
            "type":{"const":"card"},
            "title":{"type":"string", "description":"Card title"},
            "components":{
               "type":"array",
               "items":{
                  "type":"object",
                  "required":["type"],
                  "properties":{
                     "type":{
                        "enum":["text", "progress"],
                        "type":"string"
                     },
                     "content":{
                        "type":"string",
                        "description":"Label text (for type=text)"
                     },
                     "percent":{
                        "type":"number",
                        "maximum":100,
                        "minimum":0,
                        "description":"Progress percentage (for type=progress)"
                     }
                  }
               },
               "maxItems":2,
               "minItems":2
            }
         },
         "additionalProperties":false
      }
   },
   "additionalProperties":false
}

With this schema, the AI response will always contain exactly one card with a fixed title and exactly two inner components — a text block and a progress bar. The LLM only fills in the content (e.g. the label text and the progress percentage); the structure, component types, and order are fixed.

Supported output style

The rendered output is based on a fixed set of component types. Depending on the configured schema, these can include items such as:

  • title
  • text
  • markdown
  • table
  • metric
  • alert
  • key-value blocks
  • code blocks
  • lists
  • badges
  • dividers
  • sections and grouped components

This means users can guide the AI toward structured, user-friendly output without allowing completely arbitrary frontend layouts.

Example use cases

Generative UI responses are useful when an AI Processor needs to return information that users will read directly in the NetOrca GUI, for example:

  • a review of a generated configuration
  • a comparison summary of verification results
  • a list of policy issues with severity indicators
  • a deployment readiness summary with metrics and alerts
  • a structured operational report instead of a large markdown block

Example response shape

A simplified example of a Generative UI response looks like this:

{
  "components": [
    {
      "type": "title",
      "text": "Firewall Policy Review"
    },
    {
      "type": "text",
      "content": "3 rules assessed. 1 flagged for review."
    },
    {
      "type": "table",
      "columns": ["Rule Name", "Status", "Owner"],
      "rows": [
        ["Allow SSH", "Warning", "NetOps"],
        ["Allow HTTPS", "OK", "Platform"],
        ["Allow RDP", "Error", "Security"]
      ]
    },
    {
      "type": "metric",
      "label": "Total Rules",
      "value": 3,
      "suffix": "rules"
    },
    {
      "type": "alert",
      "alert_type": "warning",
      "message": "RDP rule allows unrestricted access and should be reviewed."
    }
  ]
}

In the GUI, NetOrca renders these components in order, top to bottom.

Things to keep in mind

  • Generative UI is best suited to AI responses that are meant to be consumed directly by users in the interface
  • It does not replace the need for a normal response schema when you require a strict machine-readable contract for automation
  • If the model returns invalid JSON or unsupported content, NetOrca falls back to the standard renderer

Use this feature when a human-readable, structured response is more useful than a plain markdown or JSON blob.