Operations copilot (secondary to the core dashboard)

Industrial AI isn’t a chat window taped onto a dashboard. It’s a ladder: answer the right questions, show the right evidence, then—only with guardrails—touch the system.

My role

I was the product manager for this work end to end—scope, prioritization, cross-functional execution, and the narrative we took to operators and leadership. The vision and formal initiative were set and launched by our CPO; I turned that charter into concrete bets, milestones, and shipped learning. At BeyondAI, this phase focused on engagements including Qatar Energy and QatarCool.

We treated natural language as a copilot alongside an existing operational dashboard: the dashboard remained the primary home, and language was an assistive layer for expert questions, evidence, and— with explicit guardrails—controlled actions.

Program context

Internally this work sat under an agentic AI program for Operations Advisor (OA)—extending an established advisor product with conversational access to the same underlying plans, objectives, constraints, and tags operators already trust. The charter was not “drop a chatbot next to the UI”; it was to identify opportunities, validate concepts in front of real workflows, and iterate toward capabilities that could eventually support more autonomous operation—without pretending the action framework (events, statuses, lifecycles, APIs) was optional background plumbing.

We organized the space around a small number of durable patterns: query-based use cases (human- or model-initiated), paths toward symbolic validation for high-stakes “should I?” questions, and much later agent-driven actions gated on those foundations. A living internal repository captured ideas, research, and milestone updates so engineering, design, and product could stay aligned as the stack evolved week to week. For demos and customer conversations, the concrete delivery line was packaged as the KIRA POC— a named slice of the initiative with an explicit “works today / not yet” contract.

Industrial context

Most enterprise “copilots” are really retrieval with personality. They summarize documents and draft prose. That can be useful in low-stakes knowledge work. It is not enough when the product sits next to live plans, constraints, and setpoints—when being wrong has a physical cost.

The useful way to think about an operations copilot—especially one that sits beside a mature operational UI—is as a stack of capabilities that must mature in order. You don’t earn the last step by skipping the first.

Use-case arc we sequenced

Product and engineering maintained a structured map from “interesting demo” to “operator-safe capability.” The earliest wave emphasized human-initiated expert advice: questions that only make sense with site, campaign, and plan context—for example which constraints are binding in a named process unit, how strategies differ between the previous and current plan, which objectives need mitigation, or what optimization levers exist for production or energy trade-offs. Some answers stay entirely in system state; others deliberately pair OA data with an LLM for explainability of a named objective without inventing numbers the product did not supply.

A second pattern—model-initiated retrieval of OA context—describes flows where the conversational layer needs to pull structured state from the advisor before answering or following up (“explain why…”). We treated that as a contract problem between agents, not a single prompt.

Symbolic validation was scoped for scenarios where a human expert would demand proof: “Given this scenario, should I take this action?” The intent was to minimize how much narrative context a user has to paste in, and to bias toward checks grounded in OA facts and rules rather than fluency alone.

Autonomous operations (e.g. blanket “execute mitigation across a region”) remained explicitly dependent on actions, statuses, lifecycles, reasoner outputs, and database schemas being first-class APIs—a horizon item, not a shortcut past read and validate.

A parallel CRUD-and-charts arc covered what “agent can touch” safely: Create flows such as duplicating the live plan into a draft for offline edits (while a clean-slate empty plan stayed a harder policy conversation); Read paths that return not only text but charts—time series, comparative bars, KPI-style summaries, constraint maps, and unit/zone performance views grounded in the same metrics the dashboard trusts; Update for editable fields such as condition values on live-plan objectives (triggers, constraints, actions) where product policy allowed; and Delete for draft artifacts where governance was clear. “Charts 2.0” (heavier, bespoke visualizations) was acknowledged as a later slice once the simple data contracts proved out.

A third wave—onboarding and knowledge—paired two tracks: how-to and FAQ over existing OA documentation (collection, prioritization of questions, retrieval via the company’s enterprise search stack or a lighter in-house path, then chat surfacing), and a longer-horizon knowledge extraction pipeline to draft structured entities (sites, units, zones, plans, objectives, tags, triggers, actions) from customer SOPs, PFDs, and procedures—with human review before anything touched production.

A capability ladder

1. Context-bound expert questions

Operators don’t need a generalist. They need answers that respect this site, this campaign, this plan. In delivery we prioritized answers grounded in product APIs and live system state—not generic model-only replies.

2. Evidence, not vibes: charts and structured reads

A copilot that only returns text is a glorified note-taker. Industrial users trust plots, tables, and maps—artifacts tied to tags, time ranges, and units. The product question isn’t “can the model draw a chart?” It’s whether you can pipe authoritative data into a visualization path that matches what the rest of the product already considers true—including early wins such as line series for a specified tag over a bounded window, with refinery scope explicit and tag discovery layered in later.

3. Controlled writes (CRUD) with explicit semantics

The moment the copilot helps duplicate a plan, adjust a condition value, or edit what is actually editable, it stops being read-only. This is where API design, permissions, and audit matter more than model choice. We shipped in this layer—for example draft plans created by duplicating the live plan and condition value edits where the platform exposed a safe multi-step save path—because if you can’t explain what changed, under what authority, and how to trace it, you don’t have a copilot—you have a liability wearing a chat bubble.

4. Validation: answers that can be checked

For high-stakes recommendations—should I take this action in this scenario?—fluency is not the bar. The bar is checks that mirror how a human expert would challenge the conclusion: symbolic reasoning, procedural gates, or explicit “show your work” paths tied to system facts.

5. Onboarding and configuration at scale (the long arc)

Doc-backed FAQ and extraction-to-configuration only work if downstream entities and APIs are crisp. We sequenced FAQ-style help ahead of full extraction so search integration and trust in citations could mature in parallel with heavier chart and CRUD work.

6. Autonomous action (last, and often over-marketed)

“Execute mitigation across a region” is the headline people want. In practice, it depends on event detection, ownership, notifications, and resolution loops being real—as developed in the companion write-up on alerting: detect → notify → resolve. Otherwise automation simply moves faster toward the wrong outcome—and destroys trust in everything above it.

If you’re building or buying in this space, the honest roadmap starts with questions and evidence, earns the right to writes, and treats autonomy as the capstone—not the prologue.

KIRA POC: capabilities snapshot

The following is adapted from an internal current capabilities one-pager (author: Dara Afraz) for the KIRA POC under Agentic AI for Operations Advisor, dated April 2026—meant to align sales, solutions, and product on what the copilot can credibly do in front of an operator versus what remains roadmap.

Expert queries — operational guidance

KIRA answers context-aware questions about live plans, objectives, constraints, and optimization strategies by combining OA’s internal data with LLM explainability where the narrative adds value—not where it substitutes for missing telemetry.

• Recommend actions to optimize diesel/gas production or reduce energy consumption.
• Identify unrestrained set-point adjustments available right now.
• Surface objectives requiring mitigation and which unit carries the heaviest mitigation load.
• Retrieve active constraints for a process unit within a campaign plan.
• Identify main constraints in a named system (e.g. naphtha) within the live plan.
• Explain a named objective (e.g. maximize LPG production for a specific unit tag) with process-engineering framing grounded in OA context.
• Compare previous vs current unit strategy where the product exposes both snapshots.

CRUD — plan and condition management

Through chat, KIRA supports selected create and update paths that match how operators actually prepare changes:

• Create: duplicate the live plan to produce a draft for editing before promotion—rather than minting empty plans from thin air (still a policy and API conversation).
• Update: edit condition values (trigger, constraint, or action) for a live-plan objective where the save path is complete and auditable.

In-chat charting

KIRA returns visuals inside chat backed by the same metrics contracts as the rest of OA—quick situational awareness without treating the model as the chart engine of record. Representative chart classes include:

• Bar chart of objective states (in mitigation, at target, no mitigation) by process unit.
• Line chart of performance score for a unit over a defined period.
• Bar chart of objectives by priority in the current live plan.
• Distribution of objectives across complexes.
• Bar chart of latest values for each objective in a given unit.

Not yet available (explicit gaps)

Credibility comes from saying “no” in public. The POC one-pager tracked these as intentional boundaries or backlog—not bugs to hand-wave away:

Milestones to date

When in-chat charting and broader live-plan CRUD hit natural delays, we pivoted to doc-based FAQ as near-term value—grounded in OA documentation and Beyond Search integration—while chart contracts matured. Delivery beats included:

• Jul 2025: in-chat charts demonstrated on sample data; adopted a stateless React rendering approach (embedded chart URLs / iframes in chat) so visuals match product-owned components.
• Jun 2025: Beyond Search integration began; document snippet retrieval demonstrated in chat.
• May 2025: FAQ-style doc queries prioritized; sprint demo of condition value editing and duplicate live → draft plan.
• Mar 2025: condition editing scoped across simple and range tag representations.
• Feb 2025: milestone unlocking a wide set of OA-backed queries.
• Jan 2025: chat UI embedded in OA on QA and Integration environments—making the story tangible ahead of customer and strategy conversations.

What shipped and traction

Under the KIRA POC line: first half of 2025 as the heaviest delivery window, with threads continuing beyond that (snapshot above through April 2026).

• A chat experience that answers operational questions from API-backed OA context (as opposed to generic model-only replies).
• Controlled writes in scope for the phase—including duplicating live plans into drafts and editing condition values where the platform exposed a complete, auditable save path—plus chart read paths tied to real metrics contracts.
• Documentation and onboarding direction: prioritized how-to and FAQ over OA docs via search-backed retrieval; knowledge extraction to draft configuration treated as a sequenced follow-on with explicit human-in-the-loop review.
• Progress across validation and autonomy as a deliberate sequencing framework—the heaviest emphasis where credibility with operators is won or lost: context, evidence, and guardrailed mutation.

Formal impact metrics are still maturing, which is normal in oil and gas and heavy industry. In parallel, this line of work has directly strengthened the sales pipeline and helped close two high-impact pilots that remain ongoing.

Closing

This sequencing is not conservative—it’s how you keep credibility with operators. The dashboard-first world already encodes hard-won mental models. A secondary copilot’s job is to compress time and cognitive load without pretending the legacy surface is irrelevant. That restraint is what makes the next bet—chat as the front door—a choice grounded in evidence rather than fashion.