Ask your software anything.
UXLens is the governed interaction layer for enterprise software. It turns a question into the interface that answers it - over the systems a company already runs, without moving the data, and without letting a model invent the numbers. It applies across any industry and application - and it’s at its best in commerce.
A decision surface, not another chat box.
Asking real questions of enterprise data is hard - not because the data is missing, but because answering means crossing systems, respecting each user’s permissions, and proving the numbers. UXLens is built for exactly that job: ask a question, and it composes the interface that answers it.
Over software it doesn’t own
Generates a decision surface across the tools you already run - without moving or copying your data into another silo.
Inherits your entitlements
Every query and action runs as the user and respects the row-level permissions of the source systems. Access is never approximated.
The evidence stays with the answer
Sources, lineage, calculations, freshness and coverage gaps travel with every result. Nothing is claimed without showing where it came from.
Asks a named human
A person approves before UXLens writes anything back to a system. No silent actions, no black box.
Intent goes in. A governed decision surface comes out.
Six stages turn a question into an answer. Three of them run as code against governed definitions and source-system permissions - so no model ever writes a metric formula, a permission rule, or a chart.
Intent
Question, role, entity, period, prior turns and the scope the user is permitted to see.
Context
Ontology, metric definitions, business rules and domain vocabulary - resolved as code.
Retrieval
SQL and APIs executed as the user, plus document retrieval across your sources.
Reasoning
Plan, decompose, route tools, reconcile and summarise what was found.
Interface
Select a registered pattern and compose the decision surface for this question.
Evidence
Sources, lineage, calculations, coverage gaps - and what was deliberately not claimed.
One window. Five persistent zones.
Every generated view uses the same frame, so people learn the product once and a generated interface never surprises them with a new layout. The frame is fixed; the content inside it is composed for each question.
Conversation rail
Questions, follow-ups, suggested next steps and saved investigations. The thread is the unit of work, not the query.
Decision canvas
KPI cards, comparisons, timelines, tables, maps and workflow components, composed for this question.
Evidence drawer
Sources, the query, lineage, freshness and coverage - always present, never a modal you have to hunt for.
Context bar
Entity, period, filters, scenario and role. Every chip is editable and re-runs the view.
Action layer
Share, export, propose, approve. The bridge from an answer to something that happens.
Every question returns a shape you can trust.
UXLens maps each intent to a versioned interface pattern. A model may choose the pattern and fill it - but it never invents a layout, a colour, a scale or a chart type at run time. That is what lets the same question return the same shape of answer twice.
- Why did X change? - diagnose a movement, with ranked drivers and evidence
- Compare these - evaluate options against each other on comparable terms
- What is at risk? - rank exposure by time or value, with a named owner
- Where is it? - locate and drill down by place or hierarchy
- What happened here? - reconstruct a sequence from the source record
- What should I do? - choose, check policy, and commit with approval
Grounded in five planes of context.
UXLens reads who you are, how your business is defined, and the evidence behind every answer - then adds the domain knowledge that makes an answer correct, not just fluent.
Identity & permissions
Role, team, units and workflow position - read from your identity provider and source systems, never approximated.
Governed definitions
Metrics, fiscal calendar, products, assets, customers and hierarchy - read from your semantic layer where one exists.
Domain knowledge
Terminology, causal patterns, workflows, regulation and methods - the domain pack that makes answers correct.
The live conversation
The question, prior turns, filters, assumptions and comparison set - held so a follow-up manipulates the same state.
Proof, assembled live
Sources, timestamps, lineage, quality and coverage gaps - assembled as the answer is built, never reconstructed after.