Gluesync release notes and changes

Everybody is shipping an AI assistant this year. Most of them would like you to send your schema to their cloud and trust the invoice. We went the other way.

AI Studio is a workspace inside the Control Plane where you register your own LLM providers, chat with governed Spark agents, and operate a durable agent platform:

Settings → AI agents (MCP) is still there for external MCP clients. AI Studio is for the ones that live inside the product.

Your model, your key, your rules. We just gave it a control room. See AI Studio and AI agent platform.

You know the ritual: open Query Studio, stare at a table you have never seen before, then go hunting for whichever column holds the customer id this time.

Query Studio now has a chat that already knows your schema, and Tab autocomplete that finishes the statement you started. The autocomplete is suffix-only ghost text — it proposes what comes next and never quietly rewrites what you already typed.

Both run on the same bring-your-own vault as AI Studio: same providers, same keys, same permissions. Nothing wanders off to a vendor you did not pick.

See AI helper and Tab autocomplete.

Query Studio used to be the fastest way to dump a production table into a CSV — including the email and card-number columns you forgot were there. The AI helper made that worse: a helpful SELECT * could put those cells in a model prompt.

2.3 classifies columns that look like PII (name first, sample scan when you ask), paints a tag on them in Query Studio and the Fields Editor, and masks the cells in the grid, copies, and exports. The classifier is global rather than English-only: multilingual aliases cover names, addresses, postal codes, tax ids, bank accounts, licences, and secrets, while checksum rules validate identifiers such as CPF, Aadhaar, Chinese resident ID, South African ID, TCKN, NIF/NIE, NIR, and TFN. Managers and super admins can reveal values for one session. Super admins can turn platform-wide Query Studio masking off under Settings → Global settings (it stays on unless they do). AI Studio and MCP execute_sql stay masked either way. Prefer classify_table over fishing with SQL.

See PII discovery and masking.

Your BI tool speaks SQL. Your AI stack speaks HTTP. gluesync.ai is the adapter nobody wanted to write.

The Hub owns a virtual catalog that Query Forge serves like any other table, so anything already holding a JDBC connection — DataGrip, DBeaver, Tableau, that reporting job from 2019 — can run SELECT … FROM gluesync.ai WHERE question = … and get rows back.

Behind it sit your AI providers and the read-only MCP tools. Read-only, so the worst a question can do is cost you tokens.

See AI as SQL virtual catalog.

Until now, an insert that landed on a row already sitting in the target had exactly one answer: try an upsert and hope. Sometimes that is precisely right. Sometimes it quietly overwrites a row somebody cared about, and you find out weeks later.

Now it is a per-entity setting:

Failures that are not duplicates still surface exactly as before. Targets where a duplicate key cannot arise hide the setting or caveat it, rather than handing you a switch that does nothing.

Same write path. Far fewer surprises in it.

Some values only exist on the target: a business date that comes out of a package function, a sequence helper, that one piece of logic your DBA will never let you reimplement anywhere else. The workaround used to be a second UPDATE pass, or a source-side change nobody wanted to make.

A new field function writes a target-side scalar function straight into the statement, in place of the bind placeholder — Oracle pkg.f_…, and the same shape on the other RDBMS writers that opted in. The engine that owns the value computes the value.

One pass, no round trip, and no arguing with the DBA.

It used to be either/or: an entity could carry a mapping UDF or field functions, never both. Which meant one little date conversion was enough to send you back into your Java to reimplement something that already existed as a dropdown.

That gate is gone. The UDF reshapes the row first, then field functions run on its output. Cast mismatches surface at write time instead of being blocked upfront, so the combinations we cannot prove in advance are yours to try.

Heavy lifting in code. One-liners in a dropdown. As it should have been.

An entity with a single array column used to brick the UDF editor: the mockup generator threw on ARRAY (and the same for maps), the input table stayed empty, and there was no way to write the function at all.

Core Hub now mocks array and map columns — inferring an element type from the source’s native name when Gluesync does not carry one — and the test run speaks the same Array shape agents use in production. Write it once; run it for real.

Chasing an intermittent bug through a log file carrying three weeks of unrelated history is nobody’s idea of a good afternoon.

Support — and you — can now empty Core Hub’s own log files and their rolled archives without stopping the process: POST /global-config/support/clear-logs, with an optional sweep of support archives sitting in the logs directory. Agent and Conductor logs stay out of scope; we only truncate what Core Hub owns.

Clear, reproduce, collect. The bundle you send us is finally all signal.

If you consume Gluesync off Kafka, you will have noticed that before arrived empty even when the source knew perfectly well what the old values were. Building an audit trail or a diff out of that required a certain amount of creativity.

Flip includeBeforeImage on the target config and updates carry the prior column values in before; deletes carry the pre-delete image when that is all the source sent. Leave it off and your payloads stay byte-identical to today.

Google Pub/Sub also picks up the shared transaction id that Kafka and Solace already carried, so a consumer reading from more than one broker finds it under the same key everywhere.

When two entities read the same IBM i physical file, their column attributes shared a per-table map — and quietly overwrote each other. One entity could end up decoding rows using a colleague entity’s idea of the same column.

File descriptions now stay keyed by the physical file, and each entity keeps its own column types, precision, and CCSID at decode time.

Two entities, one table, two correct answers.

An entity that sees one change a week is not in trouble. A naive quiet floor has no way of knowing that, so it paged you anyway.

v2 learns each entity’s actual cadence before calling anything inactive: sparse entities stay quiet without inventing incidents, heartbeat liveness stays an independent signal, and the overlapping target-side stall alert is off. Baselines and open incidents survive a Core Hub restart, so bouncing the Hub no longer throws away everything it learned.

Prefer the old behaviour? algorithmVersion: 1 keeps the legacy path. See Smart alerts.

Sixty-three tools was already enough to stand up a pipeline from scratch. Then Chronos asked for a seat, entity authoring wanted mappings, field functions, and UDFs on the same path, and Spark needed a way to report through the same webhook and email channels operators already configure.

The embedded MCP catalog is now 112 built-in tools. Twenty-one of them manage Chronos schedules and webhook / platform-event trigger flows through the connected module’s advertised address (your PAT, Chronos’s own RBAC). Another seventeen cover Core Hub webhook and SMTP email configuration, tests, delivery logs, and custom INFO / WARNING / CRITICAL sends. classify_table and classify_schema return PII labels only — never raw cells — so an agent can hunt for sensitive columns without SELECT *. create_entity is the short path for ordinary table-to-table work; update_pipeline closes a gap the earlier set left open; search_documentation keeps the agent from inventing docs that are not there.

Same server, same bearer token, a lot more of the product within reach. See PII discovery and masking.

A helpful answer that vanishes when you close the tab is only half useful. AI Studio now keeps searchable conversations with retention you control, so yesterday’s debugging thread is still there when finance asks what changed.

When a notification lands, you can also ask AI Studio to explain it. The helper gets a read-only tool set scoped to that alert’s pipeline, agent, and entity — no write path disguised as a summary.

The pipeline AI helper used to be read-only for every role. That kept things safe, and also kept managers copying suggestions into the UI by hand.

MANAGER and SUPER_ADMIN can now reach the mutation tools. Nothing executes on the first call: the Hub holds a pending action bound to the owner, conversation, and source pipeline, and only an explicit confirmation within five minutes runs the stored name and arguments. Cancel, expire, replay, or identity mismatch all fail closed. Connection credentials stay redacted from responses, traces, and the conversation that led there.

The model can draft the change. You still own the click.

Sometimes you need a provider gone for a week (spend freeze, outage, model swap) without wiping the vault entry and retyping secrets later.

Super admins can now flip a provider off. Credentials stay encrypted in place; chat and helpers reject that provider until you turn it back on.

Same vault. An on/off switch instead of a delete-and-rebuild.

AI Studio can freeze an agent version. Something still has to fire it when the rest of the workflow says so.

Chronos can call ai_agent_run against that published version. Prompt templates fill the run, a payload allow-list decides which fields may go in, and loop guards stop a chain from spinning the model forever.

Same scheduler. Versioned agent. Guardrails on the payload.

A UDF belongs to one entity. Built-in field functions are a fixed catalog. The gap in the middle — the same multi-column Java rule reused across a pipeline — meant copy-paste or a heavier UDF than the job needed.

Custom Field Functions are pipeline-level reusable Java functions: publish and install the collection, bind a target column in the Fields Editor (several source columns or fixed values as arguments), share the same function with other entities and UDFs, and try it in the test panel before it touches replicated data.

Logout used to clear the Gluesync session and leave the Okta / Auth0 / Keycloak session alone. The next "Sign in with SSO" click bounced straight back in.

Core Hub now discovers end_session_endpoint, returns an idpLogoutUrl after local logout, and the UI navigates there (RP-initiated logout). There is no Signout URL field to configure — discovery only — and post_logout_redirect_uri is always \{CoreHub origin}/ui/v2/login, which the customer must allowlist on the IdP. Local-realm logout still returns a null IdP URL. See Logout flow.

Some targets quote identifiers, so mixed-case column names work. Others emit unquoted DDL/DML and let the engine fold the name — Snowflake, GridGain, and Db2 for i to upper; Cassandra, ScyllaDB, Informix, and CockroachDB to lower — and Gluesync used to let you type a case the target would quietly rewrite.

Those nodes now report a single accepted case. Core Hub normalizes target columns and filter clauses on save, CREATE TABLE follows the node’s case, and the Compose UI forces it as you type. Connectors that quote identifiers still report BOTH. Existing configs stay until the next entity save.

Role alone was a blunt instrument: every Manager with Query Studio could reach every wired connection the Hub knew. Super admins can now set a per-user, per-connection matrix — OPEN or RESTRICTED — with schema and table ALLOW/DENY rules (deny wins), plus optional PII unmask grants down to a column. The same guard covers Query Studio, AI SQL, and MCP/Spark SQL, without inventing new UserRoles.

Notification explanations already had documentation search. They now also call search_support_knowledge — the same anonymized ticket search MCP clients already use — so Spark can ground an answer in past support patterns. If support search is empty or unavailable, that is not an error: the explanation continues.

The OpenAI-compatible surface grows past chat completions: streamed completions, the Responses API format, embeddings, automatic model fallback with circuit breaking, exact response caching (per owner, API key, and model), and redaction-aware Prometheus/OTLP telemetry. Call GET /api/ai/v1/capabilities to see what that node actually runs — the ledger lists only executable capabilities.

An IBM i journal reader is shared across every entity on that journal. Stopping an entity in Core Hub used to leave it on the fan-out: changes still landed in its arena file, nobody consumed them, and the only ceiling was retention — the pattern behind installations that filled hundreds of gigabytes.

Turn on suspendCaptureForInactiveEntities (unset means off, so upgrades change nothing until you opt in). After inactiveEntityCaptureSuspensionDelayMinutes (default 30) with the entity neither syncing nor snapshotting, Gluesync suspends it: the table leaves the journal read when no sibling still needs it, the entity leaves the cache fan-out, and its cache is deleted. Start it again and it catches up straight from the journal to the shared reader’s rejoin point, then rejoins the cache. If the journal can no longer reach its last confirmed position, suspension is refused. Opting in moves recovery from source-change retention to journal-receiver retention — IBM i only, and deliberate.