41 copilots, not one chat box.
A general assistant pointed at a data platform gives you confident answers about tables that do not exist. Every copilot here is scoped to one part of the platform, reads live metadata rather than a trained snapshot, and answers inside the permission model of the person asking.
Grouped the way the platform is.
The copilots divide across the same four stages as the product itself, with nothing left over. The largest group sits at the front, because getting data in reliably is where most of the work still goes.
What each one is for.
Get data in
15 copilotsBuild, run and explain the pipelines and connections that move data onto the platform.
Walks you through building an ingestion pipeline, one decision at a time.
Explains what any ingestion flow does, what it ran, and how it went.
Builds a direct source to destination flow, including connections and column mapping.
Sets up change data capture in log, query or trigger mode, with a preview before you commit.
Answers questions on advanced ETL runs: status, resources, SLA, rule checks, traceability.
Plans an ingestion deployment and validates the schedule and resources before it lands.
Monitors package runs, investigates failures and reads performance trends in plain English.
One assistant for ingestion monitoring, troubleshooting, scheduling and configuration.
Recommends throughput, resource, scheduling and connector changes for pipelines you already run.
Searches and explains every ingestion deployment, package and execution in one place.
Finds the right connector, explains its operations, and lets you test it in the same conversation.
Reports connector security posture, approvals, policies, classification and open incidents.
Tracks connector health, traces, logs and live connectivity across your estate.
Opens up projects, integrations, executions, secrets and connectivity in one view.
Designs, validates and tests an integration route as a draft before anything goes live.
Make it useful
9 copilotsDesign Spark transformations, then watch what they cost and where they slow down.
Builds a Spark transformation end to end, from catalogue search to a deployed process group.
Finds transformation deployments and reports their health, performance and cost.
Checks a transformation against the live processor catalogue and validates it before handoff.
Turns an execution into an answer: what ran, what failed, what was slow, what it cost.
Reads stage metrics, task diagnostics, shuffle statistics and the execution graph for you.
Reports package throughput, resource use, SLA compliance and failure patterns.
One assistant for Spark monitoring, troubleshooting and tuning, whatever your experience level.
Reports live cluster capacity: core allocation, memory pressure and pod demand.
Quantifies savings by category and names the over-allocated and under-allocated workloads.
Put it to work
8 copilotsQuery, publish and operate. Ask in plain English, ship an API, catch a failure early.
Writes executable SQL from a plain-English question using live metadata, never guessed names.
Turns a query into a published, parameter-validated API resource step by step.
Shows API pools, resources and clients, with usage, performance and access patterns.
Lists registered MCP servers, their tools and their health, and answers questions on them.
The consolidated view: SLAs, monitoring, rule checks, alerts, recommendations and cluster queues.
Predicts a failure 15 to 60 minutes ahead and runs the remediation before the SLA breaks.
Read-only watch on jobs, clusters, pipelines, streaming lag and catalogue failures.
Watches monitor transitions, SLO burn and synthetic failures, and routes alerts by severity.
Keep it trusted
9 copilotsProfile, classify, certify and trace every asset, and see what a schema change will break.
Verifies a new source, inspects its schema, and hands it to profiling and classification.
Builds a statistical fingerprint of every table and column, with masked previews.
Recommends assertion rules from profiling history and rolls results into a quality score.
Grants and revokes trust badges against documentation, quality and ownership checks.
Traces a field back to its source at column level and explains the derivation in plain English.
Maps schemas and columns to business terms, resolves synonyms and proposes taxonomies.
Finds personal and financial data, tags it, and propagates the label down the lineage tree.
Names every report, pipeline and dashboard a schema change will break, before it breaks.
Watches freshness, latency and health, then raises an incident to the named data owner.
The conversational surfaces underneath them.
The copilots are scoped agents. These are the general capabilities they are built on, available across the platform rather than tied to one module.
Plain-English queries over SQL, NoSQL, S3, Cassandra, and APIs.
Describe the requirement, and the agent ships a deployment-ready pipeline.
Turns verbose Spark logs into "what ran, failed, was slow, fix this."
Describe a process, and the agent generates the working script in bash, Python, Terraform, or Ansible.
Autonomous agents help with not only problem discovery but throughout the process from problem detection to auto-remediation and closure.
Ask about pipeline health and SLAs; answers come from live telemetry.
AI agents continuously enrich metadata, classify sensitive data, monitor compliance, and generate governance insights across enterprise data assets.
Describe the requirements in natural language, and the agent generates the transformation code behind the scenes to produce the output.
Every copilot above was built in a studio you also get.
The catalogue on this page is not a fixed set that ships and stops. It is what our own teams built with the tooling that comes with the platform, and the same tooling is how you add the ones we did not think of.
Waits to be asked
Answers a person in their own words, over certified data, with the source of every statement attached. Built for the people who have questions and no appetite for SQL.
Acts without being asked
Runs on a trigger or a schedule, decides what to do inside the boundaries you set, and stops for a person where you told it to. Built for the work nobody wants to own.
An agent you build starts governed.
It reads the same ontology, resolves names through the same catalogue, and answers inside the same permission model as everything else on the platform. Governance is not a layer you add to it afterwards, because there is nowhere else for it to run.
Then you have to watch them.
An agent that answers a question is a pipeline that nobody scheduled. It has runs, failures, cost and drift, and it needs the same operational treatment as anything else that touches production.
Telemetry, the same as any pipeline
Runs, failures, latency and cost across models, agents, prompts and executions, in the same operations view as your ingestion and transformation workloads.
Prompts go through release management
A prompt is tested and certified before it reaches production, and released as a version you can point at later. Changing one is a release, not an edit.
Three things that are true of every one of them.
Your permission model, not theirs
A copilot sees what the person asking is allowed to see. Row and column level rules apply to the answer the same way they apply to a query.
Live metadata, not a snapshot
Names of sources, tables and columns are fetched at the time of the question. A copilot that cannot find a column says so and asks.
On your infrastructure
The copilots run on self-hosted models inside your deployment, including air-gapped ones. No prompt and no result is sent to a model vendor.
Ask one of them something about your own stack.
Thirty minutes, your connectors, your tables. The copilots answer on live metadata, so you will see straight away whether they are useful.