An agent investigating an order problem may need transaction tables, service notes, and photographs of damaged products. Once it finds the relevant records, it still needs to know how the business defines sales, which orders count toward a cancellation rate, and how an analyst would investigate an unusual change.

These requirements bring together three challenges we encounter when building enterprise agents: fragmented data, business definitions that need repeated explanation, and context that has to be assembled again for each new agent.

At our October 20 launch, we introduced MirrorShip Intelligence Platform (MIP), our enterprise AI data platform, to bring these capabilities together. This article walks through the platform layer by layer, then follows a retail analytics task from agent configuration to an HTML report.

Three challenges behind the platform

The first challenge is the variety and location of enterprise data. One task may span structured tables, documents, images, and vector embeddings stored in different systems. Retrieving each piece is only part of the work: the results often need to be joined and analyzed together.

Our approach is to make those relationships queryable through SQL. Business tables, lake data, and representations of unstructured content can participate in a shared query path, and retrieved records can feed directly into further analysis. Where possible, computation should reach the data without requiring the original content to be moved first.

The second challenge is business meaning. Before answering “What were our sales?” an agent needs to know how sales are calculated and which orders belong in the calculation. Those decisions often live in historical SQL, documents, or an analyst’s experience. Different agents can therefore answer the same question using different assumptions.

We make these definitions explicit through Semantic View, which maps metrics to calculation expressions, relationships, and analytical dimensions. Teams can inspect the metric formula, the included data, and the SQL used to produce a result.

The third challenge is repeated setup and maintenance. Each new agent may need its own data connections, business knowledge, and analytical procedures. When a definition changes, keeping separate copies aligned creates more work.

MIP treats reusable enterprise context as a shared capability. MirrorMind organizes that context, its relationships, versions, and permissions for agents to use as needed. MirrorPilot manages the sessions and task execution that use it.

Together, these challenges explain why the database sits at the center of our design. We extend the data foundation with AI capabilities, then build upward so that shared knowledge and agent capabilities can serve more business workflows.

Three layers, one shared foundation

MIP organizes data, business context, and agent execution into three layers, with MirrorControl providing governance, security, and operational management across them. The platform’s published architecture defines their roles as follows:

  • MirrorData: The shared data foundation for queries, retrieval, and multimodal analysis. It combines MirrorBase, a real-time analytics engine built primarily on StarRocks, with MirrorLake for open lakehouse storage.
  • MirrorMind: The enterprise semantic layer. Semantic View defines calculations and data relationships; Knowledge Context connects those definitions with business rules, source material, and analytical methods.
  • MirrorPilot: A semantic-layer-driven data agent and an environment for running and delivering agent-based analytics.

Business applications sit above these layers. Performance analysis, after-sales investigation, and product selection can draw on the same foundation rather than each requiring a separate data and knowledge stack.

The examples that follow show what each layer contributes: an image-based service-record search, a campaign-budget calculation, and a retail investigation that ends with a report.

01-mip-platform-architecture

MirrorData: Connect retrieval with business analysis

MirrorData provides a shared query engine for BI reports, interactive analytics, data applications, and agents. Applications connect through standard SQL and use the same underlying query and compute capabilities.

The engine builds on StarRocks’ high-performance analytics foundation, with enterprise capabilities for access control, resource management, and workload isolation. Agent queries can therefore use the data foundation alongside existing analytical applications.

02-mirrordata-query-engine

Bring native tables, lake data, and file content into the query

The data foundation supports three common starting points:

  • Native tables: Business fields, JSON, text, and vectors can be stored as queryable data. File references and business-object identifiers connect images or documents to their derived representations and associated business records.
  • Lake tables: External catalogs provide access to existing lake data, including Paimon, Iceberg, and Hive tables.
  • Existing files: Original documents, images, audio, and video can remain in object storage. After the required parsing and embedding generation, file references, extracted text, and vectors can be written to tables and linked to business fields.

This distinction matters for unstructured content. Querying an image does not require treating the raw image file as a business-table column. Its embedding and file reference can connect it to the order, service ticket, or product it describes.

Combine structured filters, text search, and vector similarity

A business object may have structured fields, JSON attributes, text, embeddings, and references to original files. Linking these representations through an object identifier allows search results to remain connected to business facts.

MirrorData brings three query capabilities together:

  • Structured analysis: Partition pruning and columnar scans support filtering and aggregation over business data.
  • Full-text search: Inverted indexes support term matching. For example, MATCH_ANY can find service descriptions containing either of two terms for “unboxing.”
  • Vector retrieval: Similarity or distance calculations identify related content.

A single SQL query can combine these operations with joins and aggregations. The access path depends on the query and the available indexes; combining retrieval methods does not imply that every query uses the same index strategy.

03-hybrid-retrieval-and-analysis

Example: Find service records from a damaged-screen photo

For the launch demonstration, we built a service-record search interface. A user uploads a photograph of a damaged screen and looks for recent records showing similar damage, then connects those records with order and refund information.

The reference photo is first converted into a query embedding. That embedding becomes an input parameter to the SQL query; generating it is a preprocessing step.

The query then combines image similarity with a date range, a product-category filter, and full-text conditions for descriptions mentioning unboxing. Joins between service records and order details add shipment batch, carrier, and refund information.

The result is a set of relevant business records that can support further investigation. The single-query claim applies to this retrieval, filtering, and joining stage, after the query embedding has been prepared.

MirrorMind: Give agents an explicit business definition

Once an agent can access the data, it needs to know what the business wants calculated. MirrorMind provides that context through Semantic View and the supporting knowledge around it.

A Semantic View records the structured definitions needed to interpret and answer a business question:

  • Tables and relationships: Which tables are in scope and how they relate.
  • Dimensions: How metrics can be grouped, rolled up, or broken down, such as campaign budget by channel, campaign type, or date.
  • Metrics: Calculation expressions and descriptions, including derived metrics and more complex logic such as window functions.
  • Business names and synonyms: Names, aliases, and explanations that help an agent map a user’s wording to the intended metric.

The agent identifies the applicable definition, uses it to formulate the calculation, and sends the resulting query to the data engine. The definition gives query generation a business basis that table and column names alone may not provide.

04-semantic-view-interface

Localized interface illustration based on the launch material.

One question, two budget calculations

The launch demonstration asked the same question with and without a Semantic View: “What is the company’s total campaign budget?”

Without the Semantic View, the agent queried a base table containing four amount fields. It added them together and returned approximately RMB 29.16 million. The result was incorrect because the calculation included unrelated amounts.

In the demonstration’s campaign_analytics Semantic View, the total campaign budget metric was defined as total_bbbb_amount, with the expression SUM(bbbb_amount). After reading that definition, the agent selected the specified field and returned RMB 1.98 million without adding the other amount fields.

The executed query in the recording still ran against the base table. The Semantic View supplied the business definition used to choose the field and aggregation.

This example illustrates a specific distinction: executable SQL can still calculate the wrong metric. It is a demonstration of metric selection, not a general accuracy benchmark.

Keep order-level and line-item calculations separate

A retail order domain shows why these definitions need more than a metric name. One order can contain several line items, so order counts and sales amounts operate at different levels of detail.

In the example, the order subject defines order count and cancellation rate, with analysis by store and month. The sales line-item subject defines the amount actually paid after discounts, with analysis by channel, category, and product.

Their calculation boundaries are explicit. Sales include paid orders and use the line-item amount after discounts. Cancellation rate is the number of canceled orders divided by the total number of orders.

The surrounding context serves different purposes. Business rules explain inclusion criteria and exceptions; source documents provide policies and event records; analytical methods describe investigation steps; task memory retains confirmed conditions and conclusions. These elements can be maintained independently while MirrorMind manages their relationships, provenance, versions, and access permissions.

Manage knowledge as it changes

An anomaly investigation may require a metric definition, a business rule, and a standard analytical procedure. Keeping those items aligned becomes important as the business changes and more agents reuse them.

MirrorMind takes a Git-like approach to context management. Teams can create branches, retain version history, and inspect earlier snapshots. Business-reviewed versions can then be published for agents to use.

Feedback and execution traces provide inputs for the next revision. Updates can be validated before adoption, while the version history preserves what changed and why. Multiple agents can reuse reviewed definitions and knowledge without maintaining separate copies for every task.

05-context-versioning

MirrorPilot: Run the task and deliver the result

MirrorPilot brings the data foundation and enterprise context into an executable business task. Users can work through a conversational interface or invoke the capability through APIs from an existing application.

A task follows four broad stages:

  • Understand the goal: Identify the user’s request and the outcome needed.
  • Plan the work: Use relevant context and existing Skills to organize the steps.
  • Call tools: Retrieve definitions and knowledge, execute queries, and gather supporting information.
  • Process and deliver results: Return an answer or continue through additional retrieval and execution steps for a more involved task.

MirrorMind supplies the context needed for the task, while MirrorData executes queries and returns supporting data. MirrorPilot manages the running task, including sessions, task state, resource scope, budgets, timeouts, and execution records.

06-mirrorpilot-runtime

Make the output inspectable

The deliverable may be a written answer, a report, or a result returned through an API. Users need to be able to inspect the calculation as well as the conclusion.

MirrorPilot retains execution records so that users can review the SQL, metric definitions, and calculation rules behind a result. They can ask follow-up questions or trace how the task reached its output.

Reuse capabilities in existing applications

The Agent API allows an existing BI tool, business portal, or application to initiate a task and obtain results or a session link after server-side authentication. The host application can then present those results through its own interaction model.

Custom Skills extend analytical procedures, while MCP provides connections to external tools. Established query logic can also be retained as SQL templates and reused with parameters such as time range or analytical dimension, reducing repeated query-generation work for similar questions.

MirrorPilot can therefore operate as a standalone experience or become part of an existing workflow. Business knowledge, SQL templates, and Skills can be maintained and extended as the range of tasks grows.

Configure the agent through MirrorControl

MirrorControl provides the management interface for selecting an agent’s data scope, knowledge base, Semantic Views, and Skills. It also supports knowledge lookup: a user can ask how the organization defines cancellation rate and retrieve the relevant definition and guidance.

This configuration sits within MirrorControl’s broader governance and operational role across the platform. It establishes the resources and context available to an agent before the user starts a task.

07-agent-configuration-interface

Localized interface illustration based on the launch material.

A retail workflow: From configuration to an HTML report

The final example brings the layers together in an anonymized retail-customer scenario. It begins with a defined analytical scope and follows the conversation through sales analysis, anomaly investigation, and reporting.

Establish the scope before the first question

Configuration starts with the data the agent may use, the Semantic Views for the relevant business domain, and the associated knowledge base. Defining that scope helps avoid mixing unrelated knowledge and gives retrieval a narrower search space.

The setup also specifies the agent’s role, response rules, and Skills. Those Skills can describe how to handle follow-up questions, perform drill-down analysis, and format a report. Built-in query and retrieval tools provide access to the selected enterprise knowledge and semantic definitions.

Ask for sales by channel

After selecting the configured agent, the user asks for a sales breakdown by channel. The agent returns results with charts and the SQL used to produce them.

For a data-query response, the user can inspect the metric, time range, and query, then check them against the calculation definition. Keeping the query and knowledge references available makes the result easier to review.

Investigate a cancellation-rate anomaly

The user can then ask whether a metric looks normal and request a breakdown by department. For an order-cancellation investigation, the agent uses the organization’s anomaly rules and standard analytical procedures.

The responsibilities remain distinct. MirrorMind manages the rules and methods as enterprise context; MirrorPilot organizes the investigation; MirrorData executes the queries.

A further question, “Why did the cancellation rate spike?”, takes the analysis into categories, brands, and individual products. The agent also retrieves warehouse-event and inventory records, then considers them alongside changes in store cancellation rates.

The output identifies possible explanations, supporting evidence, and suggested actions for the business team to investigate. These are leads for review rather than proof that a particular event caused the increase.

Turn the investigation into a report

Once the analysis is ready, the user can ask for a management report in the same conversation. The agent organizes the task’s data, charts, business material, and findings into an HTML report that can be opened and downloaded for discussion and review.

The value of the workflow comes from keeping its parts connected. The sales figures use defined metrics; the investigation follows documented methods; the possible explanations retain their supporting records; and the final report brings that work together.

MirrorData connects retrieval to SQL analysis. MirrorMind gives agents shared business definitions and reusable knowledge. MirrorPilot turns those resources into tasks and reviewable deliverables, with MirrorControl supporting configuration and governance across the platform.

Together, they provide a common foundation for the data, definitions, and context an enterprise agent needs to complete its work.

Explore the MIP platform and launch overview for more on the architecture and demonstrations. To discuss a defined analytics use case, visit MirrorShip.