Gluesync AI Hub · What teams do with Spark agents

18 things teams actually do with AI on their own data.

AI Hub is not a chat box bolted onto a database. It is Spark agents with Core Hub tools, the Enterprise brain, your models, and your permissions, reachable from chat, SQL, schedules, APIs, and the AI clients your company already uses. These are the use cases teams start with, each with the prompt that opens it, the tools it needs, and where it runs.

  1. 01 Start with a question in AI Studio or SQL
  2. 02 Publish the agent and give it only the tools it needs
  3. 03 Schedule it, embed it, or call it from any AI client

4 use cases

Data, analytics, and BI

Data and analytics teams

Ask your data, in your words

A business question lands and the person who knows the schema is in a meeting. The answer waits for a ticket, a view, or another spreadsheet.

Spark turns the question into governed SQL on the live source or target, runs it read-only under the caller's permissions, and returns the numbers with the SQL beside them. The same question also works as a gluesync.ai row from any JDBC client.

Try

How many orders did we sync yesterday, broken down by country?

Tools
  • list_sql_capable_agents
  • list_saved_queries
  • get_saved_query
  • execute_sql
  • explain_sql
Runs in
  • Chat
  • SQL
  • MCP client

BI and reporting teams

Let the BI tool ask the question

Tableau, DataGrip, DBeaver, and the reporting job from 2019 all speak SQL. The AI stack speaks HTTP. Someone has to write the adapter nobody wants to own.

The gluesync.ai virtual table is served by Query Forge like any other table. A SELECT with a question returns one row with the plain-language answer, a proposed SQL draft that is never auto-executed, citations, and a conversation ID for the follow-up. Read-only tools only, the caller's token only.

Try

SELECT answer, proposed_sql FROM gluesync.ai WHERE question = 'which customers churned last quarter in the crm-sync pipeline?';

Tools
  • gluesync.ai
  • spark_agent
  • conversation_id
  • provider_id
Runs in
  • SQL

Analysts and team leads

Describe a chart and keep it current

Visualize ships with Gluesync 2.3.1

A simple chart of a synced entity takes a BI license, a dataset, and a refresh job before anyone sees a bar.

Describe the chart to Spark. Visualize grounds it to real columns through the Enterprise brain, renders it in the Control Plane, refreshes it by hand, on a Chronos schedule, or when the bound entity changes, and publishes a chart or a whole canvas at a stable public URL.

Try

Chart monthly order totals for the last year from the ORDERS entity and refresh it every night.

Tools
  • search_enterprise_brain
  • execute_sql
  • create_schedule
Runs in
  • Chat
  • Schedule

Enterprises with mainframe and midrange estates

Bring IBM i, Db2, and Oracle into AI without touching the host

The most valuable data sits in systems that no AI vendor connects to, and the teams that own them will not install anything new on the box.

Gluesync already replicates from IBM i, Db2, Oracle, SQL Server, and 16 dialect engines. Spark, Query Studio AI, and gluesync.ai reason over the schema Gluesync discovers and query the replica or the source read-only, so legacy data joins the AI estate without a new agent on the host.

Try

Summarize open invoices older than 90 days from the IBM i ledger and propose the SQL you used.

Tools
  • discover_tables
  • describe_entity_schema
  • execute_sql
  • explain_sql
Runs in
  • Chat
  • SQL
  • MCP client

4 use cases

Operations, DBAs, and on-call

Operations and DBAs

Triage sync health before anyone asks

Pipeline status, per-entity progress, agent metrics, and webhook dead letters live in four screens. Correlating them during an incident costs the minutes you do not have.

One question returns pipelines in error, the entity and reason behind each, growing source lag, and the dead letters that explain a silent webhook, correlated in a single answer.

Try

Which pipelines are in error right now, and why?

Tools
  • get_pipeline_status
  • get_pipeline_entities_status
  • get_agent_metrics
  • get_webhook_dead_letters
  • get_notifications
Runs in
  • Chat
  • Schedule
  • MCP client

On-call engineers

Explain this alert

A CRITICAL notification arrives at 02:00 with an entity name and an error code. The runbook is three clicks and one wiki away.

Ask AI Studio to explain the notification. Spark receives a read-only tool set scoped to that alert's pipeline, agent, and entity, searches the documentation and anonymized support knowledge, and answers in plain language with no write path disguised as a summary.

Try

Explain this alert and tell me whether it needs action tonight.

Tools
  • get_notifications
  • get_pipeline_entities_status
  • search_documentation
  • search_support_knowledge
Runs in
  • Chat
  • Schedule

Operations leads

Put the answer on a schedule

The same health question is asked every morning. Somebody opens the dashboard, copies numbers into a message, and forgets on Fridays.

Any answer Spark can produce once, it can produce every morning. A Chronos schedule fires a published agent version, the prompt template fills in the context, and the digest is delivered by email or webhook before the stand-up.

Try

Every weekday at 8am, email me a report of pipelines that fell behind overnight.

Tools
  • create_schedule
  • list_schedules
  • run_schedule
  • set_schedule_enabled
  • send_email_notification
Runs in
  • Chat
  • Schedule

Operations leads

Reach the right people, the right way

An agent found the problem. Now it has to tell someone, with the right severity, through channels security already approved.

Spark escalates through the webhooks and alert emails Core Hub already has configured, at the INFO, WARNING, or CRITICAL severity you ask for, and can summarize and mark the day's notifications as read.

Try

Notify ops by webhook and email that the orders pipeline is stalled.

Tools
  • send_webhook_notification
  • send_email_notification
  • get_notifications
  • mark_notifications_read
  • get_webhook_configurations
Runs in
  • Chat
  • Schedule
  • API

5 use cases

Platform and integration engineering

Platform engineers

Improve a pipeline configuration

Write settings, polling intervals, and column mappings were chosen on day one and never revisited. Changing them by hand means reading YAML nobody remembers.

Spark reads the current configuration, explains what it would change and why, and applies it only after a Manager or Super admin confirms. Nothing executes on the first call; a pending action expires after five minutes.

Try

Review the orders-to-analytics pipeline and suggest safer write settings.

Tools
  • get_pipeline
  • export_pipeline_yaml
  • update_pipeline
  • list_field_functions
  • compile_mapping_function
Runs in
  • Chat

Platform engineers

Stand up pipelines from a conversation

Three new pipelines mean three trips through the wizard, each with the same connection details and the same mapping decisions.

Describe the pipelines once. The Pipeline creator keeps an ordered multi-pipeline plan in the conversation, resumes the first incomplete item on continue, scrubs credentials before they reach the model, and runs the same completion transition the wizard uses so the pipelines leave Draft when they are actually ready.

Try

Create three pipelines from the SAP source to PostgreSQL analytics: customers, orders, and invoices.

Tools
  • create_connection
  • add_agent
  • create_pipeline
  • create_entity
  • verify_pipeline_connections
Runs in
  • Chat

Integration engineers

Automate inside and outside Core Hub

Your ETL needs a fresh snapshot of one entity on demand, and your release process needs a pipeline drained and restarted without a person watching the screen.

Trigger flows with their own token, sync commands, and webhooks let Spark run the operation and hand the result to your own systems. Destructive tools park in the chat with Confirm or Cancel; writes from API keys wait for a signed-in approval.

Try

Create a trigger flow that runs a one-time snapshot of the invoices entity on demand.

Tools
  • create_trigger_flow
  • fire_trigger_flow
  • list_trigger_flows
  • start_sync
  • stop_sync
  • one_time_snapshot
Runs in
  • Chat
  • Schedule
  • API

Data quality teams

Validate a migration and reconcile the differences

After a snapshot, someone still has to prove that source and target agree, and explain the rows that do not.

Spark starts a Validator comparison, reads the result, and explains the differences in business terms. In a chained Chronos event the comparison runs right after the snapshot, and the agent's summary reaches the team before the morning check.

Try

Compare CUSTOMERS on source and target after last night's snapshot and summarize the differences.

Tools
  • trigger_data_comparison
  • get_data_comparison_run
  • list_data_comparison_differences
  • reconcile_data_comparison_differences
  • send_email_notification
Runs in
  • Chat
  • Schedule

Developers

Embed a governed agent in your own application

Product wants an assistant inside the customer portal. Security wants to know which model it calls, with whose key, and what it costs.

Your application starts runs through the native /api/ai/v1 contract or the OpenAI-compatible /v1/chat/completions endpoint with a scoped gsa_ key. Budgets return 402 before spend runs away, rate limits and allow-lists bound the key, and every run keeps a redacted outcome and an ordered event timeline.

Try

POST /api/ai/v1/agents/support-triage/runs with an idempotency key and a correlation ID.

Tools
  • /api/ai/v1/agents/{slug}/runs
  • /v1/chat/completions
  • gsa_ platform keys
  • budgets
Runs in
  • API

3 use cases

Security, compliance, and governance

Data governance

Discover where your data hides

Nobody is sure which of the 1,400 tables in the ERP hold personal data, or which ones changed since the last replication review.

Point Spark at a connection and let it walk schemas, tables, and columns, classify PII by column name and optional sample scan, and shortlist the entities worth replicating. Classification returns labels only, never raw cells.

Try

Which tables in the ERP source hold customer personal data?

Tools
  • discover_schemas
  • discover_tables
  • discover_columns
  • classify_table
  • describe_entity_schema
Runs in
  • Chat
  • MCP client

Security and compliance

Hunt for sensitive columns without SELECT *

Compliance wants proof that every column holding tax IDs, card numbers, or health data is known and masked. Sampling production tables by hand is the risk you are trying to avoid.

classify_table and classify_schema return PII labels only. Query Studio and the AI helper mask the classified cells in the grid, copies, exports, and model prompts, and a per-user data-access matrix decides who may unmask a column. A monthly schedule can run the sweep and report new findings.

Try

List every column classified as PII across the billing pipeline that is not yet masked on the target.

Tools
  • classify_schema
  • classify_table
  • describe_entity_schema
  • list_field_functions
  • send_webhook_notification
Runs in
  • Chat
  • Schedule
  • MCP client

Engineering and product teams

Close the loop in GitLab, Notion, or Slack

The agent found the failing entity. The fix lives in a GitLab issue, the runbook in Notion, and the team in Slack.

Approved company tools are HTTPS MCP servers registered on the Enterprise brain with an allow-listed host and an encrypted token. Agents that carry the tool bundle can open the issue or post the update during a run; remote calls count as writes and wait for a signed-in approval.

Try

Open a GitLab issue for the CUSTOMER_ADDR source timeout and link today's run.

Tools
  • remote:<serverId>:<toolName>
  • publish_skill
  • search_enterprise_brain
Runs in
  • Chat
  • Schedule

2 use cases

Executives and the whole company

Executives and business teams

Answer the executive question in the chat they already use

Leadership asks faster than the BI team can publish views, and each answer becomes another extract that drifts from the source.

Claude, ChatGPT, Grok, Meta Muse, Cursor, or any MCP client connects to Core Hub, searches the Enterprise brain for the tables behind the question, and hands it to a published Spark agent. Every call runs with the permissions of the person asking; the brain stays on your infrastructure.

Try

Which tables feed the quarterly revenue forecast, and when were they last synced?

Tools
  • search_enterprise_brain
  • list_published_agents
  • start_agent_run
  • get_agent_run
Runs in
  • MCP client
  • Chat

Everyone who operates Gluesync

Learn every Core Hub corner

Documentation, support knowledge, global configuration, and license details are each one menu away, and the question is never about just one of them.

Spark answers in context: how Gluesync handles a schema change, which global settings differ from the defaults on this Core Hub, what the license allows, and which past support cases looked like this one.

Try

Which global settings differ from the defaults on this Core Hub?

Tools
  • search_documentation
  • search_support_knowledge
  • get_global_config
  • get_license_info
  • get_corehub_version
Runs in
  • Chat
  • MCP client

How it works

Every use case follows the same three moves.

  1. 01

    Ask

    A question, in the surface you already use

    Chat in AI Studio, a SELECT FROM gluesync.ai in your SQL client, or a prompt from Claude, ChatGPT, Grok, Meta Muse, or Cursor connected to Core Hub. Spark grounds it in the Enterprise brain and the tools on its allow-list.

  2. 02

    Publish

    Freeze what worked

    Instructions, skills, tool allow-list, routing policy, and limits become an immutable agent version. Spark can also publish the procedure it just ran as a reusable skill the whole company can call.

  3. 03

    Operate

    Run it on a trigger, with a budget

    Chronos schedules and events, webhooks, chained pipeline steps, your application through the API, or a SQL row. Runs are durable and idempotent, spend is budgeted, and writes still wait for a person.

Where they run

Five surfaces, one agent platform

A use case is not tied to where it was first tried. The same published agent answers in chat, as a row, on a schedule, behind an API, and inside the AI client of your choice.

Chat

AI Studio

Governed Spark agents with persisted conversations, tool traces, alert explanations, and confirmed pipeline writes, inside the Control Plane.

  • Caller RBAC on every tool call
  • Per-agent MCP allow-list
  • Searchable conversations with retention
AI Studio →

SQL

Query Studio AI and gluesync.ai

Schema-grounded drafts and Tab completion in the workbench, and a virtual table any JDBC client can query for an answer row.

  • Read-only tools only
  • proposed_sql never auto-executed
  • PII masked before the model
SQL AI →

Schedule

Chronos and AI Workflows

Published agents fired from cron, platform events, webhooks, and chained events, with prompt templates, payload allow-lists, and loop guards.

  • Idempotency keys absorb retries
  • Writes wait at WAITING_APPROVAL
  • Delivery through approved webhooks and email
AI Workflows →

API

Native and OpenAI-compatible

Start runs through /api/ai/v1 or call /v1/chat/completions, /v1/responses, and /v1/embeddings with scoped gsa_ keys, budgets, and fallback routing.

  • model: auto routing
  • 402 before runaway spend
  • SSE event timeline per run
Developer API →

MCP client

Claude, ChatGPT, Grok, Cursor, and more

The Core Hub MCP server exposes 125 tools and the Enterprise brain to any MCP-capable client, under the caller's token.

  • search_enterprise_brain
  • start_agent_run and get_agent_run
  • publish_skill with the right scope
Connect your AI tools →

Build your own

Starters, skills, and Craft with Spark

Query, Automate, Report, Route, and Investigate starters, immutable skills, and an agent that drafts agents turn a new use case into a published version in an afternoon.

  • INSTRUCTION, TOOL_BUNDLE, and KNOWLEDGE skills
  • JSON output contracts
  • Routing preview before the first token
AI Studio docs →

FAQ

AI use cases: questions we hear

Do these use cases need a data scientist or prompt engineer?

No. AI Studio ships starter patterns (Query, Automate, Report, Route, Investigate) and the use cases on this page map to them. A Manager picks a starter, adjusts the instructions, selects the Core Hub tools the agent may call, and publishes a version. Spark can draft the agent for you with Craft with Spark.

Which model runs them?

Whichever you register in the bring-your-own vault: OpenAI, OpenAI-compatible endpoints, Anthropic, Azure OpenAI, or a local Ollama model. The routing policy picks per run by capability, residency, health, price, latency, and quality, and you can preview the decision before any tokens are spent.

Can an agent see data the user could not?

No. Every tool call runs with the permissions of the signed-in user, the API-key owner, or the Chronos run owner, through existing Core Hub RBAC and Query Studio data-access rules. Columns classified as PII are masked before they reach the model.

Which of these change something, and how is that controlled?

Reads flow immediately. Writes need the tool on the agent's allow-list and the role to use it; proposed pipeline changes wait for a confirmation that expires after five minutes, destructive tools park with Confirm or Cancel, and writes from API keys or Chronos pause at WAITING_APPROVAL for a signed-in person.

Can I start in chat and move to automation later?

Yes, that is the intended path. A question you asked once in AI Studio becomes a published agent version, and the same version is fired by a Chronos schedule, an event, a webhook, your application, or a gluesync.ai row. Nothing is rebuilt between the surfaces.

Do any of these need a release after Gluesync 2.3.0?

Everything on this page ships with Gluesync 2.3 except Visualize, which arrives with Gluesync 2.3.1 and is marked as such. Gluesync Connect, the hosted control plane for many sites, is coming soon, planned for Q4 2026, and available through the waitlist.

Gluesync AI Hub

Pick one use case. The platform is already there for the other 17.

Every use case on this page runs on your models, your infrastructure, and your permissions, with Gluesync 2.3. Book a demo and bring the question your team keeps asking.