Search docs.molo17.com

    Gluesync release notes and changes

    Welcome to the Gluesync release notes. This page provides detailed information about each release, including new features, improvements, and fixes.

    📬 Stay in the Loop!

    Looking forward to keep you updated on Gluesync releases? Subscribe to Gluesync Updates to receive our latest news and updates, including new features, improvements, and fixes right into your inbox. We promise to keep it short and not spammy.

    Latest Release: 2.3.2.2

    Released: November 13, 2026

    Gluesync 2.3.2.2: one-click Platform updates come to Kubernetes

    Release highlights

    Dear data wranglers,

    On Docker, updating Gluesync has been one click in the Core Hub UI for a while, thanks to Conductor. On Kubernetes it still meant a Helm upgrade and a careful eye on your pipelines. Not any more: the Gluesync Kubernetes Operator is now available, and the same Platform updates panel updates Core Hub and its modules on your cluster too.

    Gluesync Kubernetes Operator (GKO): Platform updates on Kubernetes

    • Same panel, every platform: GKO connects to Core Hub as its Conductor module, so Update all, or a single component, in the Core Hub UI updates Core Hub, Chronos, Grafana, Prometheus and GKO itself on Kubernetes, as Conductor does on Docker, Docker Swarm and Podman

    • Pipelines kept safe: every running pipeline is put into maintenance mode while Core Hub changes, and resumed as soon as Core Hub is ready again

    • Stability check and rollback: Core Hub goes first, then the modules one by one, and a component that does not come up on its new version is rolled back to its previous image. GKO updates itself last, and the old GKO rolls the new one back if it does not come up

    • GitOps ready: one GluesyncPlatform custom resource (kubectl get gsp) holds the desired version, module pins and update policy, and with updatePolicy: gitops versions follow Git or Argo CD instead of the UI

    • Disaster recovery from the UI: Settings → Disaster Recovery sets up a disaster-recovery pair on Kubernetes, and a Kubernetes site pairs with a Docker site

    • Fits your cluster: offline installs and private registry mirrors are supported, recent Kubernetes kits install GKO for you, and it is open source with its own Helm chart

    • See Gluesync Kubernetes Operator (GKO), Install GKO and the GKO changelog

    Additional improvements

    • Core Hub:

      • A snapshot read retried after a failure, or restarted after a cancellation, resumes from the checkpoint the target last wrote instead of the one the launch started with, so rows already written are not read and copied again;

      • A CDC start that fails after a completed snapshot (a source agent that does not answer, a source, target or storage failure) raises one critical alert saying CDC did not resume, with its error type and cause, instead of being logged and dropped or warned twice as "Start entity interrupted";

      • GSSD-1487: An entity created through MCP keeps the nullability discovery reports for the key columns of an existing target table instead of storing them all as NOT NULL, which made the writers miss rows whose key holds a NULL;

      • An inbound collection attached to an HTTP Source is deleted only when forced, which detaches it from the HTTP Source;

      • A configuration import refused for its payload is logged at WARN with the reason instead of at ERROR as "Failed to dispatch configuration to agents";

      • The AI Studio editor chats (Spark in the UDF editor, custom function editor, Query Studio, AI SQL, notification explanations, prompt drafts, Visualize) and the Spark agent, pipeline helper and Chronos chats stream the provider answer instead of waiting for one body, so a slow answer through Gluesync Connect no longer fails with an HTML 504 from the proxy, and a provider HTTP error is reported with its status;

    • UI:

      • GS-1458: Added a "Resumable snapshot" setting to the fine tuning of a single table entity of a SQL source;

      • The start dialog reads the copy progress of every selected entity and no longer offers to continue a snapshot that Core Hub refuses (a table copied without key order), naming the tables that start over instead of failing the command with a 409;

      • Courier: The route editor follows the new inbound routes: a route is a method, a path, an operation and its bindings, a read route declares its filters, response fields and key, the request preview uses the Courier inbound port, the HTTP Source names its inbound collection, and New entity shows the method of each HTTP Source table;

      • Courier: An entity built on a PATCH route warns until its target skips absent columns, and "Set to Skip column" writes the policy where Core Hub reads it, so the entity is no longer refused after the click;

      • Courier: An inbound collection with endpoints, or attached to an HTTP Source, can be deleted, with a confirmation that detaches it from its pipeline;

      • Courier: The tooltips of the collection tree and of the endpoint forms stay inside the window instead of being cut by their pane, and the Inbound and Outbound tabs use the same size;

      • Modules Manager: The Kubernetes operator is named "Gluesync Kubernetes Operator" instead of "-" or "gluesync-operator", also when its image comes from a Nexus mirror, and the reverse proxy "Traefik reverse proxy";

      • Updates: The update panel waits for the Kubernetes operator to restart as it does for Conductor, so a second update sent during its hand-over no longer fails with "A service is temporarily unavailable";

    • Kits:

      • Courier inbound on port 8090: from v0.0.298 (November 17, 2026), every kit sends /api-inbound/ to Core Hub’s inbound server over HTTPS instead of plain HTTP, which the reverse proxy answered with 500 on Core Hub 2.3.2.2. This covers the Kubernetes Helm chart (scheme: https with serversTransport: insecure-transport on the courier IngressRoute) and the Docker Compose and Docker Swarm kits on Linux and Windows (scheme=https on the Courier route of Core Hub). The kits no longer tell you to set inboundAllowPlainHttp. On an existing Kubernetes install, run helm upgrade with the new kit; on Docker Compose, Conductor makes the change, see Conductor 0.14.4 and, for Kubernetes routes added by the operator, GKO 0.4.2;

    • Agents:

    2.3.2.1

    Released: November 11, 2026

    Gluesync 2.3.2.1: meet Courier, your pipelines now speak REST in both directions

    Release highlights

    Dear data wranglers,

    Last time we taught CDC to rewind and kept a second site warm. This time we went after the one system in every integration project that has no database to read, only an API. Until now that meant a script, a cron job and a long debate about who owns it when it stops. Not any more: Courier brings REST APIs into Gluesync as first-class citizens, so a pipeline can deliver its changes to an API, or take records from one, with the same entities, mappings and checkpoints you already use for databases.

    Here’s what’s new:

    Courier: REST APIs become sources and targets of your pipelines

    Describe an API once, in the web UI, and every pipeline can use it. Courier is the REST editor of Core Hub, and the HTTP agent (courier-agent) that ships inside Core Hub puts it to work. Nothing to deploy, nothing to connect: open Courier in the menu and start describing.

    • HTTP Target, changes out to any API: a collection holds the base URL and the authentication (Basic, Bearer or API key), and its endpoints hold the verb, path template, headers and typed bindings. The pipeline sees a collection as a schema and an endpoint as a table, so pointing a source table at an API is the same as pointing it at a database: pick the endpoint, map the columns. Every captured insert, update and delete becomes one HTTP call

    • Sent twice, applied once: every request carries an Idempotency-Key that stays the same when Core Hub hands the change over again, after a retry or a resume. A non-2xx answer fails the write and it is retried from the checkpoint, and a DELETE answered 404 or 410 counts as delivered

    • HTTP Source, records in over HTTP: publish inbound endpoints (CREATE, UPDATE, DELETE) and let a SaaS webhook, a device or your own app push records to them. Each authenticated request becomes one pipeline row, forced to disk before the client gets 202 Accepted, and the pipeline delivers it to any target, at least once and in order per endpoint

    • Secure before it’s convenient: inbound calls need a Personal API Token with the HTTPS agent scope, owned by a Manager or a Super Admin and admitted by the collection’s allowlist and blocklist. Credentials and header values are encrypted at rest and masked in every answer. Outbound calls never follow redirects and never reach loopback, link-local or cloud metadata addresses unless you allow it with GS_COURIER_ALLOW_LOCAL_EGRESS

    • Calm under pressure: limits on body size, requests in flight, queue size and free disk answer 408, 413 or 503 with Retry-After instead of falling over. Send test request and the latest 50 results of every endpoint show exactly what the API answered

    • See HTTP Source and HTTP Target, Source setup and Target setup

    Your pipelines already spoke SQL, NoSQL and streaming. Now they speak HTTP too.

    Additional improvements

    • Agents:

    • Core Hub:

      • GSSD-1501: A key that changes again after an insert and a delete cancel out inside one bulk batch is written, instead of every later change to it being dropped while the transaction was confirmed, which lost a row inserted, deleted and inserted again in the same batch;

      • GSSD-1488: The status of a pipeline that is unhealthy for a failed migration names the migration and asks to click Retry, instead of an error banner with no text at all;

      • GSSD-1488: A pipeline stays failed until every agent of a migration retry has migrated, instead of a retry that failed on a later agent answering with an error while the pipeline looked healthy and the failed migration came back at the next boot;

    2.3.2.0

    Released: November 10, 2026

    Gluesync 2.3.2.0: restart from any point in time, disaster recovery, query your lake files, run on Podman

    Release highlights

    Dear data wranglers,

    Last time we taught Databricks four new ways to sign in and gave the MCP server a little more patience. This time we went after the question every on-call engineer has asked at least once: "can we just replay everything since Tuesday at 14:00?" Now you can, with no snapshot and no long night. While we were at it, Query Studio learned to read the files your pipelines drop in the lake, a second Core Hub can now stand by to take over when the first one is lost, Gluesync stopped insisting on Docker, and the snapshot settings got a speed test, so you can stop guessing thread counts.

    We’ve been busy. Here’s what’s new:

    Point-in-time restart: rewind CDC, skip the snapshot

    A bad deploy, a truncated target table, a downstream job that ate an afternoon of rows: until now the way back was a full snapshot. Now you pick a moment and Gluesync replays everything since.

    A stopped entity can restart CDC from a past date and time, or from a native position of its source, instead of from its last checkpoint. The changes made after that point are read from the source again and written to the targets, with no snapshot.

    • In the Start dialog, choose Point in time: Gluesync shows where each entity will restart before anything changes. Measure twice, restart once

    • Native positions: SQL Server CDC LSN, Change Tracking version, IBM i journal receiver and sequence, MySQL and MariaDB binlog file and position, Oracle LogMiner and XStream SCN, Informix LSN, SQL Anywhere log offset, Vertica epoch, MongoDB resume token, DynamoDB stream position, ScyllaDB cdc$time, Couchbase Eventing event counter, and the transaction id of the Db2 LUW, Db2 LUW CDC, SAP HANA, Oracle Triggers Legacy and Sybase trigger-based agents. Couchbase DCP and Cosmos DB restart from a date and time

    • The changes between the restart point and where each target had got are written as upserts of every column, whatever the insert conflict and changed columns settings, so a restart repairs the target instead of stopping on rows it already holds

    • A point older than the oldest change the source still keeps is refused, never moved forward. Oracle XStream has a new restart horizon (hours, 0 by default) that keeps that much history reachable

    • REST: POST /pipelines/{id}/restart-positions/resolve previews the positions and POST /pipelines/{id}/commands/sync/start-from restarts the entities. MCP: resolve_restart_positions and start_sync_from_point

    • Not available on Oracle Triggers, the Sybase log reader, PostgreSQL and YugabyteDB (a replication slot cannot go back), the legacy IBM i DSPJRN reader, and Couchbase Eventing while Delete Events On Sync Confirmed is on. See the Point-in-time restart column of Supported integrations

    It’s the same CDC. It just learned to go back in time.

    Disaster recovery: a second site that’s ready before you need it

    Hope is not a disaster-recovery plan. A second Core Hub is.

    Two complete Gluesync sites form a pair: the active site runs your pipelines and schedules, and the standby keeps a copy of everything the active site stores, about one second behind, ready to take over if the active site is lost.

    • Guided setup from the Control Plane on sites that Gluesync Control installed: start the first site, copy the pairing code, join the second. The keys between the sites are exchanged for you. On Kubernetes, Docker Swarm or a compose file you manage, set the GS_DR_* variables instead

    • Core Hub replicates its six databases (pipelines and configuration, notifications, metrics, AI brain, data comparison results and the Chronos scheduler) over one connection on ports 1718 and 1719: no object storage, no shared disk

    • Failover is manual by default: a planned switchover when both sites are healthy, a forced promotion when the active site is down. Automatic failover with a witness is opt-in

    • A site that was active never comes back as active: it rejoins as the standby of the site that took over, so two sites never run the same pipelines

    • After a takeover, the After a takeover setting decides what happens to the entities whose undelivered changes were lost with the old site: Manual (the default) holds them until you decide, Resync automatically resyncs them, Resume accepting the gap resumes them from their checkpoint

    • See Set up a disaster-recovery pair, Run a disaster-recovery pair end to end and Upgrade a disaster-recovery pair

    It’s still Gluesync. There are just two of them now, and they agree on who’s in charge.

    Query your lake files: Parquet, CSV and JSON, no extra tool required

    Your pipelines have been landing Parquet on S3 for a while. Reading it back meant another tool, another set of credentials and another browser tab. Not any more: Query Studio and Query Forge read the files the Gluesync file agents write, with an embedded DuckDB engine inside Core Hub and the connection the agent already has.

    • AWS S3, S3-compatible endpoints included, and the Universal File Store agent over WebDAV, WebDAVS or NFS

    • Each entity reads as a table of the default schema. parquet('path'), csv('path') and json('path') read a file directly, and files('folder') lists a folder

    • Read only: one SELECT or WITH per query, up to 10,000 rows or 8 MiB of results

    • Settings: GLUESYNC_LAKE_MEMORY_LIMIT (512MB), GLUESYNC_LAKE_THREADS (2), GLUESYNC_LAKE_MAX_TEMP_DIRECTORY_SIZE (4GB), GLUESYNC_LAKE_MAX_CONCURRENT_QUERIES (2) and GLUESYNC_LAKE_SCRATCH_DIR ($DATA_DIR/lake)

    • Azure Data Lake, Google Cloud Storage, FTP, FTPS, SFTP, SMB and CIFS are not read yet

    • See Query Studio and Query Forge

    It’s still Query Studio. It just learned to read what your pipelines write.

    Podman, rootful and rootless: Docker is now optional

    For the security team that winced every time a container ran as root: Gluesync runs on Podman on Linux, rootful or rootless, installed and operated by Gluesync Control as on Docker.

    • gluesync install --runtime podman, with --rootless or --rootful

    • Core Hub 2.3.2.0 runs as a non-root user (uid 1017) in its container, so rootless Podman, keep-id and runAsUser deployments start it without a data folder owned by root. Chronos does the same from 0.3.3, and Conductor recognises Podman from 0.14.1

    • See Gluesync on Podman

    Same Gluesync, fewer root privileges.

    Snapshot autotuning: let the speed test pick the threads

    Readers, writers, bulk size, page size: four knobs, and until now a well-informed guess. The speed test turns the guessing into measuring:

    • From the Start dialog, Open the speed test copies the entity into a temporary test table on the target, with the same columns and secondary indexes, and tries reader and writer counts, bulk and page sizes within 2, 5 (default) or 10 minutes

    • It ends with the snapshot settings it proposes and an estimated copy time, and Faster starts the entity with them

    • One entity at a time, from a single-table SQL source to a SQL target: SQL Server, PostgreSQL, Greenplum, YugabyteDB, CockroachDB, Oracle, MySQL, MariaDB, SingleStore, Db2 LUW, SAP HANA, ClickHouse and IBM i. It is refused when fewer than 5 source connections would stay free

    • REST /pipelines/{id}/autotuning, the MCP tools check_snapshot_autotuning and start_snapshot_autotuning, and an ENTITY_AUTOTUNING_FINISHED notification

    It’s the same snapshot. It just stopped running on folklore.

    Import entities from a file — bring a YAML or ZIP, see every table before it lands

    An Automator export already describes every table of a pipeline. Getting those entities into the Control Plane still meant running the Automator again, or picking the tables one by one on the New Entity page and redoing each mapping and setting by hand.

    The New Entity page now reads that file itself. Import entities in the Selected entities pane, or Or import them from a file when nothing is selected yet, takes a YAML or ZIP file and turns it into entities of the pipeline you have open.

    • A .yaml, .yml or .zip file of up to 100 MB, read in your browser. A ZIP may also hold at most 1000 entries and 100 MB unpacked

    • Every table is checked before anything happens: Gluesync reads the source and target tables, then Core Hub validates each entity. Nothing is changed while the file is validated

    • Each row shows a status, from Ready to Unsupported. Fix a row in the dialog: another source table, the operations, the target keys, a filter condition, or the full field mapping through Customize. The YAML file itself is never changed

    • On relational targets, Create missing target tables is on by default: the tables the target lacks are created from the source columns when the entities are saved

    • A ZIP brings its code too. Its UDFs are compiled when you save, as a copy when an entity of the pipeline already uses the name. Its Custom Field Functions are installed with Compile and publish on a pipeline that has none installed; a collection already installed is never replaced

    • Adding the rows to the selection saves nothing. Groups, target tables, UDFs and entities are written only when you press Confirm and continue; entries that are not ready stay on the page for you to fix and confirm again

    • The entities are not started. Start snapshot and CDC yourself, as for entities you build by hand

    • Schedules in the file are reported, not created, and unlocked schemas are refused. The import is open to SUPER ADMIN and MANAGER

    The same file the Automator reads. This time you see every table before it lands.

    Additional improvements

    2.3.1

    2.3.1.4

    Released: November 2, 2026

    Gluesync 2.3.1.4: log upload with a ticket voucher, data comparison fixes for Databricks

    Release highlights

    Dear data wranglers,

    2.3.1.4 completes the Databricks target with more ways to sign in, Unity Catalog metadata and lineage on the tables Gluesync creates, and wide decimals that no longer refuse writes. The MCP server now works behind your reverse proxy out of the box and no longer gives up on slow operations.

    Databricks: more sign-in options, Unity Catalog metadata and lineage

    • New authentication modes: OAuth token federation, Microsoft Entra service principal, and Sign in with Databricks (user-to-machine OAuth), alongside service principal and personal access token, each with its own credential fields

    • Tables Gluesync creates carry a table comment and properties, plus optional Unity Catalog tags (new option Publish Unity Catalog tags, off by default)

    • Optional lineage from each source entity to its Delta table, through Unity Catalog external lineage (Public Preview) or OpenLineage, each off by default

    • A DECIMAL wider than 38 digits is written as STRING instead of failing every write

    • A throttled or failing token endpoint is reported as such, not as refused credentials

    • See Databricks

    • New Apache CouchDB source and target agent for CouchDB 3.3, 3.4 and 3.5, on a single node or a cluster, over the HTTP JSON API with no vendor SDK. As a source it lists the ids from the _changes feed and reads the documents with parallel _bulk_get requests (94,000 documents per second with 16 requests at a time), resumes an interrupted snapshot from the feed position it had reached, and follows the _changes feed for CDC, replaying the changes made during the snapshot. As a target it writes with parallel _bulk_docs requests, looks up revisions, retries conflicts, deletes with tombstones, merges partial changes and creates databases with the number of shards you choose, the main lever of the write throughput (15,000 documents per second with 2 shards, 81,000 with 32 on a single node). Attachments and purges are not replicated. See changelog;

    Additional improvements

    • Core Hub:

      • Every support ticket has a voucher, GSV-XXXX-XXXX-XXXX, shown on the ticket page of the support portal and in the e-mail sent when the ticket is opened. Settings → Support → Log collection for support uploads the log archive straight into the ticket with it (Support voucher), up to 5 GB, in resumable parts of 16 MB, with the size verified. The voucher is valid while the ticket is open and for 30 days after it is closed. See Your ticket voucher;

      • The host needs outbound HTTPS to the support portal API and to *.s3.eu-central-1.amazonaws.com. GLUESYNC_SUPPORT_API_URL overrides the address of the API;

      • The ticket number and e-mail address remain as a legacy option, over WebDAV only: Core Hub no longer falls back to FTP and no longer uses curl;

    • Validator and data comparison

      • Databricks array, map and struct columns are now compared by their JSON form, so they no longer show up as differences when the pipeline wrote them correctly.

      • A MongoDB decimal or a date nested in an object or an array is compared as the source agent hands it on, instead of as the Extended JSON of the document, which reported one mismatch per document holding such a value;

    • MCP

      • The MCP endpoint accepts requests on any hostname unless you restrict it with GLUESYNC_MCP_ALLOWED_HOSTS, so it works behind a reverse proxy without extra setup; requests stay authenticated and the browser origin check stays on.

      • Slow operations called through MCP, such as attaching an IBM i connection or waiting for a trigger flow, no longer fail after 15 seconds while Core Hub completes them.

    • Spark

      • The agent chat attaches the tools a turn needs and loads the others on request instead of sending the whole allow-list every round, so an agent set to All tools no longer exceeds OpenAI’s limit of 128 tools and its first round drops from 208 tools and 117,781 characters of schema to 18 tools and 8,562;

      • A request that exceeds the provider’s tool limit is refused before the call with a message naming how many tools to remove, and a routed completion moves on to the next model, instead of the provider answering with a raw HTTP 400 body;

    • Core Hub

      • GSSD-1481: Upload Logs to Support holds the connection open for the whole archive and upload instead of being cut at the ten minute REST timeout, and rotated .gz logs go into the tar.xz as they are, which took 1.4 seconds against 252 seconds on 1 GB of gzipped logs, with the free space checked first;

      • GSSD-1473: The operations that replace an earlier one on the same key are counted and logged once per list, instead of one warning per operation, which on a source whose key is not unique wrote 1,575,925 lines in two hours and slowed the snapshot down;

      • Saving an entity whose sides carry new agent entity ids replaces the stored side instead of adding one, which left the entity with two target sides and every later save refused as a duplicated entity side;

      • GSSD-1471: /authentication/me answers 401 instead of an unhandled 500 when it finds no user;

      • The cache eviction loop of an agent that leaves its pipeline is stopped, instead of running on the cleared configuration and failing every fifteen minutes after the pipeline was deleted;

    • Web UI

      • Every notification toast now dismisses itself, errors after 10 seconds; the notification drawer keeps the history.

      • The how-to guides tooltip is no longer clipped in Settings and the notification drawer, and the functions hint can be dismissed.

    • Agents

    2.3.1.3

    Released: October 29, 2026

    Gluesync 2.3.1.3: SAP SQL Anywhere joins the catalog, and CDC resumes exactly where it stopped

    Release highlights

    Dear data wranglers,

    2.3.1.3 brings the SAP SQL Anywhere agent, as a source that reads the transaction log and as a target. CDC on SQL Server, ScyllaDB and DynamoDB now resumes from the right position every time, Couchbase and Aerospike writes keep their order, IBM i keeps pace with busy journals, and the Validator stops flagging data the pipelines wrote correctly.

    New agent: SAP SQL Anywhere

    • Source: committed transactions read from the transaction log with dbtran, with no triggers or tables in your database

    • Target: INSERT, MERGE, key-matched deletes and a bulk path through OPENSTRING

    • SQL Anywhere 17 and later, with the SQL Anywhere 17 client mounted into Core Hub

    Additional improvements

    2.3.1.2

    Released: October 28, 2026

    Gluesync 2.3.1.2: steadier snapshots, safer shutdowns and tighter TLS for MySQL and MariaDB

    Release highlights

    Dear data wranglers,

    2.3.1.2 is a reliability update on top of 2.3.1.1: every row of a partitioned snapshot gets read, Core Hub shuts down cleanly, memory stays under control across all your pipelines, MySQL, MariaDB, PostgreSQL, YugabyteDB and Informix CDC keep up with far more small commits, and MySQL and MariaDB connections verify the server you trust.

    Additional improvements

    2.3.1.1

    Released: October 27, 2026

    Additional improvements

    2.3.1.0

    Released: October 25, 2026

    Gluesync 2.3.1: write only what changed, start where you left off, and three new databases join the party

    Release highlights

    Dear data wranglers,

    Two weeks ago 2.3.0 handed you AI on your own keys and a write path where you make the calls. 2.3.1 keeps going in the same direction: fewer wasted writes, snapshots that pick up where they stopped without skipping a row, and three new agents.

    Here’s what’s new:

    Write policies — only the columns that actually changed

    A CDC update used to rewrite the whole row on the target, even when one column moved. Now each entity picks its own write policy:

    • Changed Columns Only writes just the columns the transaction changed

    • Skip Unchanged Rows drops an update whose non-key columns did not change

    • For a value the source doesn’t have (a SQL NULL or a missing document field), write NULL, leave the column out, or let the target use its default

    A row an update does not find on a document-store, key-value or wide-column target is created with its unchanged fields too. Targets that always write a whole row, such as BigQuery, Cosmos DB and Microsoft Fabric Open Mirroring, and entities that write in bulk refuse the policies when you save, so nothing silently ignores your choice.

    Start where you left off — and see it before you click

    The new start dialog shows where each entity resumes from before you start it. Pick snapshot and CDC options, set the snapshot speed, and change several entities at once, also on a phone.

    An interrupted snapshot is continued only when it was read in key order, so it no longer skips rows. Otherwise it starts over and tells you why.

    Three new agents: Greenplum, Vertica and SAP ASE

    Faster snapshots into SQL Server

    Snapshot pages into SQL Server now stream through one bulk copy kept open across pages, instead of one copy per page. Wide tables and high-latency links benefit most.

    Query Studio in your pocket

    Query Studio on Gluesync Mobile is rebuilt for the phone around cards and bottom sheets:

    • A query editor with SQL highlighting, quick-action chips and a connection picker that remembers your recent connections

    • Results in a mobile table, with a detail sheet for each row

    • Query history and saved queries one tap away, and the AI helper laid out for the small screen

    Additional improvements

    2.3.0

    2.3.0.4

    Released: October 23, 2026

    • Core Hub:

      • New Remote support button (lifesaver icon) in the top bar: enter the ID of your open MOLO17 support ticket and Core Hub opens a separate Gluesync Connect tunnel through connect.molo17.com, so MOLO17 support can reach this Core Hub for 24 hours. The ticket is checked with MOLO17 before anything is opened, and a ticket that does not exist or is not valid is reported. Revoke closes the access at any time, and it closes on its own after 24 hours. Requesting or revoking it needs permission to change the configuration;

      • The field mapping reads the target tables again each time it opens, so a table created after the page loaded is listed, and a target table with no columns shows an error instead of loading forever (GSSD-1438);

      • 28 Japanese translations, such as Delete, Edit entity and Exit maintenance, no longer end in a leftover <<<<<<< HEAD;

    • Security:

      • Vulnerabilities from the Trivy report 2106, including CVE-2026-110879, are patched by raising Netty, Jackson, Bouncy Castle, Jetty, httpcore5, lz4-java and org.json to their fixed releases, updating the Couchbase SDK to 3.13.0 and PostgreSQL JDBC to 42.7.14, and moving the base image to Azul Java 21.0.12;

    • Agents:

      • Aerospike agent, see fixes and improvements:

        • TLS connections open again: the Netty transport classes the client uses to recognise its event loop group now ship with the agent, so TLS connections no longer fail with "Unexpected EventLoopGroup";

    2.3.0.3

    Released: October 21, 2026

    • Core Hub:

      • Leaving maintenance returns at once and reconfigures agents and restarts entities in the background, so large pipelines no longer hit the 10-minute REST timeout and stay half-configured (GSSD-1427);

      • Saving connection credentials no longer fails with a 500 after 600 seconds on a busy Core Hub: the connection is saved first, then pushed to every agent, and a rejecting agent is named in the error (GSSD-1431);

      • Deleting a pipeline in maintenance, also with the MCP delete_pipeline tool, removes its replication slots, triggers and shadow tables from the database;

      • A second target on a pipeline or an entity is refused on save, validation, agent assignment and configuration import;

      • A start with snapshot on an entity whose snapshot is complete warns that only CDC runs, and names Restart sync from zero and the one-shot snapshot;

      • Snapshot metrics count only snapshot pages, and a new snapshot run on a buffering target restarts its progress;

      • Metrics updates no longer scan the whole entity metrics table (metrics database schema 6, migrated at startup);

      • Secrets in the legacy format are re-encrypted in the background after startup, after a backup to gluesync.db.pre-reencrypt.bak, so reading pipelines on upgraded installations is fast again;

      • Webhook delivery logs the storage key cannot decrypt are rewritten empty instead of failing every retention cleanup;

      • Anonymous usage analytics has its own consent, on by default and separate from telemetry, in Settings → Support and through the MCP tools get_usage_analytics_status and set_usage_analytics;

    • Query Studio:

      • Cell edits, row inserts and deletes, and ? parameters work on MariaDB, MySQL, SingleStore, Oracle, Db2, Informix, Snowflake and Vertica;

      • A query with a PostgreSQL cast such as email::int no longer opens the Query Parameters prompt;

      • PII unmask grants apply when the driver leaves out a column’s schema or table, and aliases or expressions over masked columns stay masked unless every column is granted;

      • A masked column can no longer leak through a cast, an expression, or a database error message, and values in database errors no longer reach the Core Hub log;

    • Query Forge:

      • Database errors about queries on masked columns are redacted;

    • Security:

      • commons-lang 2.4 (CVE-2025-48924) is removed by updating Apache Calcite to 1.42.0 (GSSD-1433);

    • Agents:

      • New Microsoft Fabric Open Mirroring target agent: snapshots and CDC as Parquet change files in a Fabric mirrored database (GS2-606). See changelog;

      • New Supabase target agent: snapshots and CDC into Supabase Postgres with the PostgreSQL write path and TLS on by default. See changelog;

      • PostgreSQL agent, see fixes and improvements:

        • Bulk operations and batch writes handle every type of the type matrix, keep the type of money, numeric, bit(n) and unbounded varchar staging columns, and write dates before 1582 exactly;

        • CDC keeps timetz offsets, replicates NaN and infinities (wal2json 2.6 or later), and no longer turns an update of an array key into a delete and an insert;

        • CDC resumed from a saved position no longer drops changes of interleaved transactions, and the replication slot is confirmed only up to what the target has stored;

      • YugabyteDB agent, see fixes and improvements:

        • CDC resumed from a saved position no longer drops changes of interleaved transactions, and the replication slot is confirmed only up to what the target has stored;

      • Oracle LogMiner agent, see fixes and improvements:

        • Rows written after a higher-SCN commit and savepoint rollback rows with an unresolved transaction id are no longer dropped (GSSD-1245);

        • New logminerMaxWindowScns setting caps the span of a mining window (GSSD-1245);

      • ScyllaDB agent, see fixes and improvements:

        • CDC starts on tables with an empty CDC log, no longer carries the previous change’s old values, and composite-key updates and deletes work;

      • Db2 for IBM i agent, see fixes and improvements:

        • Multi-member files are resolved for all tables at once, so leaving maintenance on large pipelines no longer times out (GSSD-1427);

      • Solace PubSub+ agent, see fixes and improvements:

        • Each agent connects with its own client name, so two agents on one broker and Message VPN no longer disconnect each other;

      • Aerospike agent, see fixes and improvements:

        • With Use batch writes on, each record gets only its own row’s bins;

      • Amazon DynamoDB agent, see fixes and improvements:

        • Unprocessed batch-write items are retried instead of dropped, and stream reads ask for at most 1,000 records, so source CDC no longer fails on every poll;

    • Chronos:

      • Chronos 0.3.1, see changelog:

        • Cron schedules with both a day of the month and a day of the week run when either matches, as standard cron does, with the new day_or setting to require both;

    • Documentation:

      • Target pages document that bulk operations during CDC apply an update as a delete plus an insert;

    • UI:

      • Snapshot metrics show Snapshot Time Left;

      • The entity edit screen has Exit, Discard and exit and breadcrumbs;

      • The Gluesync Connect tunnel shows as reconnecting for up to 5 minutes after a Core Hub restart;

      • Settings → Support → Clear Logs empties Core Hub’s logs without a restart;

      • A pipeline in maintenance can be deleted from its gear menu;

      • Trackpad swipe gestures work again in desktop Chrome and Edge;

    2.3.0.2

    Released: October 19, 2026

    • Agents:

      • New Databricks target agent: snapshots and CDC into Delta Lake tables in Unity Catalog through a Databricks SQL warehouse, over HTTPS with an OAuth service principal or a personal access token. Changes are applied with key-matched Delta MERGE statements, bulk snapshots load from a Unity Catalog volume, and Query Studio and data comparison run on the same warehouse (GS2-607);

      • New Elasticsearch target agent, with OpenSearch as a flavor of the same agent: snapshots and CDC into Elasticsearch and OpenSearch indexes through the _bulk REST API. Missing indexes are created with a mapping generated from the entity columns, and every operation on a row reaches the same document, so a replay writes it once;

      • New Redis Streams target agent: appends every snapshot row and CDC change to a Redis Stream with XADD, standalone or cluster, with flat or JSON entries and optional stream trimming. The existing Redis agent is unchanged;

      • Topic prefix on the Solace PubSub+, Google Pub/Sub, and Apache Kafka target agents (GSSD-1428): an optional agent setting placed in front of every topic name the agent builds, for destinations such as acme/erp/<collection>/<action>. Solace joins it as topic levels with /, Pub/Sub and Kafka add it as typed (end it with . to get acme.orders). A prefix the broker would refuse is rejected when the entity is set up, before the first message. Left empty, topic names are unchanged;

      • Apache Kafka agent: snapshots and CDC are written up to 190 times faster, and Use Transactions now works. See fixes and improvements;

      • Solace PubSub+ agent: in persistent mode a batch counts as written only once the broker has it, a broker rejection is retried instead of lost, and large snapshots no longer run Core Hub out of memory. See fixes and improvements;

      • MS SQL Server CDC agent: snapshots into SQL Server run 1.6 to 1.8 times faster with bulk operations, and bulk copy no longer fails on real columns or cuts datetime2 values. See fixes and improvements;

      • MS SQL Server Change Tracking agent: the same target improvements. See fixes and improvements;

      • PostgreSQL agent: an update that changes the primary key now reaches the target as a delete plus an insert, and hstore columns can be replicated. See fixes and improvements;

      • YugabyteDB agent: an update that changes the primary key now reaches the target as a delete plus an insert. See fixes and improvements;

    • AI Studio:

      • Spark can add the new Databricks, Elasticsearch / OpenSearch, and Redis Streams agents to a pipeline;

    • UI:

      • Buttons, table cells, list rows, and status labels show the compact spinner again while they load; full-page, panel, and dialog loading keep the Gluesync loader;

      • The Databricks, Elasticsearch, and OpenSearch agents show their logos, and Query Studio formats Databricks queries as Spark SQL, keeping backtick-quoted names;

    2.3.0.1

    Released: October 15, 2026

    Upgrade note

    2.3.0.1 moves gluesync.db and gluesync-ai-brain.db to new schema versions that a 2.3.0 Core Hub cannot open. Core Hub copies each file before migrating (gluesync-ai-brain.db.pre-v1.bak for the brain database); to go back to 2.3.0, put those copies back. Deleting the brain database is not a way back: conversations, memories, skill attachments, and remote MCP servers would be lost.

    • Core Hub:

      • EBCDIC code pages in field functions — Byte Array to String and String to Byte Array offer the national single-byte EBCDIC code pages (IBM037, IBM273, IBM277, IBM278, IBM280, IBM284, IBM285, IBM297, IBM500, IBM871), each with its euro variant (IBM01140 to IBM01149), plus IBM1047 (z/OS Latin-1). An IBM i CHAR … FOR BIT DATA column (CCSID 65535) read with Translate binary off can now be turned into text without a UDF, from the Fields Editor or the MCP create_entity / draft_entity tools;

      • Fields Editor, NoSQL targets: a discovered target type that would be incompatible with the source column is replaced by the matching target type (for example PostgreSQL timestamp with time zone maps to Couchbase offset_date_time instead of string), and a discovered field picked by hand offers every compatible type;

      • PII discovery no longer flags composite column names built on a generic word, such as project_name, company_name, file_name, mac_address, server_address, mobile_app_version, or zip_file. name and address on their own, and person-qualified names such as customer_name or billing_address, are still PII. Boolean columns get no name verdict, and a stored automatic name verdict that no longer applies stops masking right away;

      • Email alerts to multiple recipients (GSSD-1403) — Settings → Notifications → Emails takes up to 20 recipients, one per row, with inline validation. Alerts and the digest reach every address as a separate message, so a rejected address does not drop the others and recipients do not see each other. GET / PUT /global-config/smtp accept the alertEmails list; the single alertEmail still works;

      • Validator on chained entities — the Validator compares the tables of a chained (multi-table) entity one table at a time instead of refusing the entity. Pick the table with tableId on the data comparison API or table_id on the MCP trigger_data_comparison and list_data_comparison_runs tools; history, reconciliation, and events are kept per table;

      • The READ button of a notification opens the Notifications hub also when the Control Plane is served under a custom base path, instead of landing on Pipelines;

      • User groups for query data access — super admins can create groups of local and OIDC users in a new User groups settings tab, and bind data-access policies and templates to a group as well as to a single user. A user’s own policy on a connection replaces their groups' policies there, and a policy on a single connection can now be deleted on its own; otherwise their groups' policies combine (OPEN when any group is OPEN, rules and PII unmask grants unioned, deny wins). Administrators can see a user’s effective policy;

      • New anonymous GET /health liveness endpoint for Docker, Kubernetes, and load balancers: it answers {"status":"UP"} without touching the database or the license. /metrics/hw-stats adds the disk usage (total, usable, used) of the data directory volume, measured on the filesystem of the data directory rather than on the container’s image overlay;

      • The support bundle’s pipelines-config.json now carries (GSSD-1407) each entity’s snapshot and performance settings (fetch and batch sizes, polling interval, partition column and count, target snapshot writing concurrency), never partition bounds or free-text SQL commands;

      • REST paths accept an encoded backslash (%5C), so a source table with a backslash in its name can be configured through the API; encoded control characters are refused;

      • Security fix: a pipeline id, agent id, or UDF name in a REST path can no longer reach a file outside the pipeline’s data directory, also when written with an encoded slash or backslash (%2F, %5C); such requests answer 400;

      • A browser request for a missing page under /ui/v2 answers 404 instead of redirecting to itself until the browser gives up;

    • Query Forge:

      • Query Forge identifies itself to SQL clients as Gluesync Query Forge; with the Gluesync JDBC driver 1.1.0, DBeaver shows the product and driver versions;

      • GET /query-forge/driver and the read-only MCP tool get_query_forge_driver_info report the latest Gluesync JDBC driver and whether it is an update for the caller;

      • Much more of a query runs on the source database: filters, projections, aggregates with GROUP BY, ORDER BY, LIMIT / OFFSET, joins, UNION ALL, IN lists and the functions BI tools generate, so a COUNT(*) on a large table now finishes. See How Query Forge runs a query;

      • Joins across agents read far fewer rows: aggregates run on each agent first, a selective side sends its keys to the other database, and large sides are merged or read by key. See Aggregates over joins across agents;

      • Results stream page by page, and a query that would hold more than 1,000,000 rows of one table fails with SQLState 54000 instead of exhausting Core Hub’s memory; a connection sets its own cap with maxScanRows. See Limits;

      • A long queryTimeout also extends each call to the source, closing a connection cancels its queries, a server-side statement timeout stops long queries, and a burst of BI queries can no longer pile up on Core Hub. See Cancel queries and set timeouts in BI tools;

      • Results are exact whichever database or plan computes them: decimals keep their declared precision and scale and compare by value, AVG and SUM of integers return DECIMAL and BIGINT, TIMESTAMP and DATE keep their stored value, correlated subqueries are exact around `NULL`s, and non-Latin text and emoji are handled;

      • Every error carries a meaningful SQLState, and the Gluesync JDBC driver reports every failure as a SQLException. See Troubleshooting;

      • A masked column reaches the source only as a plain read, a comparison with a value of its own type, or a count. See PII masking in Query Forge;

      • Tables created, dropped, or altered on a source show on an open connection when you refresh it;

    • Query Studio:

      • Reading a page of a large result no longer makes the database produce the whole result for every page;

      • Cancelling a query stops that query, not whichever query started last on the same agent;

      • DATE and TIMESTAMP (without time zone) values are returned as the wall-clock value the database holds, without the Z suffix, so the grid shows them correctly in any browser time zone and no longer moves a time in the daylight-saving spring-forward hour. Columns with a time zone keep the instant form. Scripts that call the Query Studio REST execute endpoint and parse these values as instants must be updated. See Date and time values;

      • A column you mark as PII or as not PII by hand (GSSD-1344) is now masked or shown that way in query results too, including SELECT *, aliased columns, and tables written in a different case, not only in the schema tree. Marking a column as not PII needs a data-access grant that can unmask it (HTTP 403 otherwise), and the schema-tree menu offers only the action that applies. In a query over several tables, a column you marked as not PII is unmasked only for its own table, so a join no longer unmasks a column with the same name in another table;

    • Visualize:

      • Spark can group a date by day, week, month, quarter, or year, so "licenses by quarter" becomes one point per quarter. Its catalog search skips each database’s own system schemas, reads a physical database once even when several agents point at it, and stops after 30 seconds with what it found, offering to search longer;

      • Chart errors name the agent (for example Agent 'HR SQL Server (SOURCE)' is not running) instead of its id, and Spark no longer grounds a chart on a pipeline in maintenance unless you pick that pipeline. A proposal bound to one shows a warning;

    • AI Studio:

      • AI Studio settings backup and restore: every AI setting of a Core Hub (LLM providers, AI Studio agents, models, skills and agent versions, remote MCP servers, Enterprise brain settings, platform API keys, budgets and each user’s conversation retention) exports as one bundle and imports into another Core Hub with the same ids and versions. Secrets travel only when asked, sealed with your passphrase. See Back up and restore AI settings;

      • Spark can export the AI settings and check an import with two new MCP tools, export_ai_settings and import_ai_settings; secrets never pass through them;

      • AI settings export with secrets checks your role before the passphrase, and after five wrong passphrases no passphrase is accepted for fifteen minutes;

      • Spark answers cut at the model’s output limit are marked as incomplete instead of looking finished. The notice is saved with the conversation, typing "continue" finishes the answer, and no SQL or Java draft is offered from a cut answer. Output budgets are larger: 8,192 tokens in the UDF and custom function editors, 4,096 in Query Studio chat and AI SQL;

      • When a brain build cannot read some agents, AI Studio names each agent and its pipeline instead of listing bare agent ids;

      • The Enterprise brain Catalog panel lists the indexed tables and its search finds them, instead of reporting "No tables indexed yet";

      • The Atlassian (Jira & Confluence) company tool signs in without editing the allowed hosts: the wizard now allow-lists Atlassian’s authorization server too;

    • Security:

      • Personal API Token scopes are enforced on every request (gluesync.api, gluesync.api_read, gluesync.mcp, gluesync.mcp_read, gluesync.jdbc_gateway), new tokens need at least one scope, and tokens without scopes keep full access as Full access (legacy). See Personal API Tokens and scopes;

      • Read-only scopes always run queries read-only, tokens can no longer manage tokens, a token limited to some agents reaches only those agents, and an MCP session answers only the token and user that opened it;

      • Query Studio’s read-only mode refuses data-modifying statements and functions with side effects, and runs read-only queries in a read-only transaction. See Read-only mode;

      • Support archives are downloaded and uploaded only from Core Hub’s logs directory, and names taken from requests or imported configurations can no longer point outside their directories;

    • Agents:

    • UI:

      • The Query Forge driver download shows the JDBC driver version and what changed in it. When a newer driver is out and you have a Query Forge token, a red badge on the Query Forge toolbar offers Download and Mark as updated. See Driver versions and updates;

      • Entity add and edit: each table in Selected entities shows a tag for every feature turned on for it (field function, UDF, filter, bulk), and clicking a tag opens the dialog where that feature is configured;

      • Fields Editor: several warnings fold into one banner with View warnings, which opens a new Warning tab, the same way several errors already open the Error tab;

      • Pipelines: entity rows flash green when new metrics arrive, and the rps chip turns green while it shows a value, so you can see at a glance what is replicating;

      • Entity detail: Field Mappings shows the column mapping with arrows, including N:1 and 1:N relations, field functions, custom field functions, and the UDF, instead of pairing columns row by row;

      • Query Studio: the schema tree column menu offers Mark as PII or Not PII according to the column’s current state and your unmask grants (GSSD-1344);

      • Validator: pipelines are sorted by name, and a pipeline in maintenance shows a badge;

      • Add to group: group names show in full and are sorted by name (GSSD-1421);

      • Fields Editor: a cell’s menu closes once its cell scrolls out of sight instead of staying over the header;

      • UDF editor: Delete UDF moves next to Test as an icon button, and the screen shows a loader until the UDF code is ready instead of an empty editor;

      • Chronos scheduler: unselected days in the weekly picker show as outline buttons, so the selected days stand out;

      • The Platform updates dialog no longer hides behind other dialogs, such as the Query Studio announcement;

      • Loading states across the Control Plane use the Gluesync loader;

    • Gluesync JDBC driver: see the JDBC driver changelog;

    2.3.0

    Released: October 13, 2026

    2.3 is our biggest release to date, containing 100+ new functionalities across any module. Make sure to test it in your dedicated test environment before moving to production.

    Gluesync 2.3.0: bring your own brain, pick your own write rules, and let the target fill in its own blanks

    Release highlights

    Dear data wranglers,

    Last time we taught your CDC readers to remember where they were and your Grafana dashboard to stop lying about lag. This time we went after the last place Gluesync was still deciding things on your behalf: the quiet ones. AI now runs on models you own, with your keys and your permissions — and every spot in the write path that used to guess for you is now a choice you get to make.

    We’ve been busy. Here’s what’s new:

    Spark & AI Studio — your models, your keys, your rules

    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 — and Spark now shows up wherever you already work.

    Build and run

    • Bring OpenAI, an OpenAI-compatible endpoint, Anthropic, Azure OpenAI, or a local Ollama box that never leaves your network. Credentials live in an encrypted vault that only super admins administer, with optional token prices so managers can watch estimated spend before finance does

    • Agents run with the signed-in user’s permissions and a per-agent tool allow-list: nobody gets an AI-shaped way around your RBAC, and an agent reaches exactly what you handed it

    • Publish immutable skills and versioned TEXT agents, then start asynchronous runs with duplicate protection, redacted outcomes, and a durable SSE timeline. Conversations are searchable, with retention you control

    • The fixed eight-round tool cap is gone. A loop policy bounds each turn by step ceiling, identical-call fingerprints, failure streaks, duration, and cost, and says why it stopped. Every step of a published run is persisted, so a Hub restart resumes what is safe or marks an at-most-once write ambiguous instead of pretending it finished

    Govern and integrate

    • Route against a canonical model catalog by capability, context, residency, health, price, and weighted quality — and preview every inclusion or exclusion before a request runs

    • Owner/API-key budgets, scoped one-time gsa_ secrets, rate limits, usage accounting, and an audit trail

    • Native /api/ai/v1 plus OpenAI-compatible /v1/models and /v1/chat/completions, with streaming, 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. GET /api/ai/v1/capabilities lists only what that node actually runs

    • The model proposes, you press go. MANAGER and SUPER_ADMIN can reach pipeline mutation tools, but the first call is only a pending action bound to owner, conversation, and pipeline; an explicit confirmation within five minutes runs it, and cancel, expiry, replay, or identity mismatch fail closed. Destructive tools (delete_pipeline, delete_connection, reset_pipeline_checkpoint, delete_entities, redo_sync) park in the chat with Confirm / Cancel; API-key and Chronos writes wait at WAITING_APPROVAL for a signed-in human. Credentials stay redacted throughout

    Spark across the product

    • Query Studio AI helper — a chat that already knows your schema, plus suffix-only Tab ghost-text autocomplete that proposes what comes next and never rewrites what you typed. Same vault, same keys; classified PII cells are never sent to the model

    • AI as SQL — the Hub-owned gluesync.ai catalog is served by Query Forge like any other table, so anything holding a JDBC connection (DataGrip, DBeaver, Tableau, that reporting job from 2019) can run SELECT … FROM gluesync.ai WHERE question = … and get rows back. Read-only, so the worst a question can do is cost you tokens

    • Pipeline creator — keeps an ordered multi-pipeline plan in the conversation, resumes the first incomplete item on continue, and leaves Draft through the same completion transition as the wizard once the final SOURCE and TARGET are attached. Ask for three pipelines, get three pipelines

    • Ask Spark checks the manual — every chat gets read-only search_documentation and search_support_knowledge, used only when you ask for help and cited only from what they return, with links on https://docs.molo17.com. Notification explanations use them too, with a read-only tool set scoped to that alert’s pipeline, agent, and entity

    • Chronos — the Schedules and Events pages open a Spark panel grounded on that page. Managers and super admins can ask it to create, change, pause, run, or delete schedules and trigger flows; every write waits for your confirmation. Chronos 0.3.0 can also run a published agent through ai_agent_run, with prompt templates, payload allow-lists, and loop guards

    Settings → AI agents (MCP) is still there for external MCP clients. See AI Studio and AI agent platform, AI helper and Tab autocomplete, and AI as SQL virtual catalog.

    Enterprise brain — one shared memory for every agent and every AI client

    Executives ask questions faster than anyone can ship a new BI view, and published agents used to forget everything the moment a run ended. The Enterprise brain begins where Gluesync is already good: it walks the databases you integrate and turns the schema into a graph an agent can reason over.

    • A dedicated gluesync-ai-brain.db beside gluesync.db holds the schema graph (including foreign-key edges from MySQL, MariaDB, Oracle, SQL Server, and Db2), agent memory, conversations, skill attachments, and approved company tools

    • Memory is shared by default across everyone who uses an agent; say "keep this private" and it stays yours. Memory records location and procedure, never rows or secrets

    • Keyword search is always on; embeddings are suggested the moment a model with the EMBEDDINGS capability exists. Agents can publish the procedure they just executed as a skill

    • Company tools — pick from the preset gallery (Slack, Gmail, GitHub, GitLab, Notion, and many others) or add a custom HTTPS MCP server, then discover tools and publish them as tool-bundle skills. Unregistered hosts are refused and remote writes wait for approval

    • Microsoft — the gallery includes the Microsoft Agent 365 servers (Outlook, Microsoft 365 Calendar, Teams, Word, OneDrive and SharePoint, keyed by your Entra tenant ID), Microsoft Foundry, Azure Resource Manager, and the credential-free Microsoft Learn search

    • Token or OAuth — paste an access token once (stored encrypted), or, when the server advertises OAuth (GitLab’s MCP answers 403 to a personal access token), let Core Hub run the PKCE sign-in and store a scoped token. Nothing is written before the callback, and the redirect works behind a reverse proxy or Gluesync Connect

    • Field catalog and ranked search — the walk now counts fields per table, and the Enterprise brain dashboard opens a catalog you can drill into: type, primary key, foreign key. The same Query Studio data-access policy that already gates SQL hides tables you cannot see. Search ranks memories and schema hits for the question instead of dumping the first fifty, and the chat transcript shows an Enterprise brain sources block for what it used. Company tools can be signed in per user over OAuth (your token, your run, your private memory). A vendor readOnlyHint on a published tool skips the approval card — that hint is the vendor’s word, not a Gluesync audit. Those tools also show up on the Core Hub MCP server as company_<server>_<tool>, so Claude or Cursor can call them without a second hop

    • Outside clients — a copyable setup prompt plus the list_published_agents, start_agent_run, get_agent_run, publish_skill, and search_enterprise_brain MCP tools let Claude, ChatGPT, Grok, Meta Muse, Cursor, Hermes Agent, OpenClaw, or any MCP client ask your brain, under the caller’s permissions

    You own it, you control it, and it is not SaaS. See Enterprise brain.

    Write path — you choose the rules, the target computes the blanks

    Every spot in the write path that used to guess for you is now a choice you get to make — and the transformations around it finally work together.

    • Insert conflict strategy — when an insert lands on a row already in the target, each entity picks UPSERT (today’s default, unchanged), SKIP (keep the target row and move on), or FAIL (say "duplicate" out loud and stop). Non-duplicate failures surface as before; targets where a duplicate key cannot arise hide or caveat the setting

    • Scalar function call — a 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 other RDBMS writers that opted in). Business dates, sequence helpers, that logic your DBA will never let you reimplement: one pass, no second UPDATE

    • Custom Field Functions — pipeline-level reusable Java functions: publish and install a collection, bind a target column in the Fields Editor with several source columns or fixed values as arguments, share it across entities and UDFs, and try it in the test panel first. See Custom Field Functions

    • Field functions and UDFs together — an entity can carry both. The UDF reshapes the row first, field functions run on its output, and cast mismatches surface at write time instead of being blocked upfront

    • UDFs grow up — array and map columns no longer brick the editor (Core Hub mocks them and the test run uses the production Array shape), and every UDF receives an isSnapshot flag to tell the initial load from CDC

    • Target column name case — targets that fold unquoted identifiers declare one accepted case (Snowflake, GridGain, and Db2 for i upper; Cassandra, ScyllaDB, Informix, and CockroachDB lower). Core Hub normalizes columns and filter clauses on save, CREATE TABLE follows, and the Compose UI forces it as you type

    Heavy lifting in code. One-liners in a dropdown. Far fewer surprises in between.

    Fields Editor — draw the mapping instead of negotiating with it

    The old Fields Editor paired each source row with exactly one target row. Anything else, like two columns into one, one column into two, or a target column with no source, meant unlocking the schema and hoping the next edit still remembered what you did.

    Now you draw it. A gutter sits between the source and the target table, and every relation is an arrow you drag from one dot to another. A click or the keyboard works too.

    • Every shape, on purpose: 1:1, N:1, 1:N, a source you read but do not write, and a target column fed only by a field function or the UDF. M:N is refused. On an N:1 target, Add a custom field function opens the editor with a function already declared on those source columns and binds it once you publish it

    • Proposed, not imposed: arrows are proposed by name (exact case first, then a unique case-insensitive match) or by ordinal position. Reset mapping brings the proposal back, and Clear mapping removes every arrow

    • Keys follow the arrows: keys are derived from the physical keys and the arrows. A source primary key cannot be linked to a non-key column of a target that has a primary key, and the editor tells you why

    • Undo, one step at a time: removing an arrow marks it and offers an Undo, and a tooltip names both ends of the marked arrow. Scroll lock keeps both tables and their arrows moving together

    • Edits that survive schema drift: a saved column that discovery no longer returns drops only its own arrows. A target column gone from the database stays as a row tagged "No longer in the database" and blocks the save until you delete it

    • Types where you own them: the type menu of a NoSQL, Event Streaming, or Object Store field, a table Gluesync creates, or a field you added lists every target type. A NoSQL type inferred from samples (a timestamp stored as string, say) is mapped to the source-compatible type when an arrow lands on it

    Migrating an entity with an unlocked schema: unlocked schemas are no longer supported. The first time you edit an entity saved with an unlocked schema or unlocked data types, a migration automatically tries to give you the mapping and the UDFs it needs: arrows are proposed again from fresh discovery, and the entity’s UDF, settings, filters, and key mapping are kept. Your replication is not affected until you save, and Leave unchanged exits without touching it. If the migrated entity needs anything else to keep its previous behavior, contact MOLO17 support and we will help you set it up. See Migrating unlocked schemas and Fields Editor.

    The mapping is finally a picture of what actually gets written.

    MCP catalog at 125 tools

    Sixty-three tools was already enough to stand up a pipeline from scratch. The embedded MCP catalog is now 125 built-in tools, all on the same server and bearer token:

    • Pipeline authoring — create_entity is the short path for ordinary table-to-table work, with mappings, field functions, and UDFs on the same path; update_pipeline closes the gap the earlier set left open

    • Chronos — 21 tools for schedules and webhook / platform-event trigger flows, through the connected module’s advertised address (your PAT, Chronos’s own RBAC)

    • Notifications — 17 tools for Core Hub webhook and SMTP email configuration, tests, delivery logs, and custom INFO / WARNING / CRITICAL sends, so Spark can report through the channels operators already configure

    • Validator — six tools to start comparisons, read differences, and reconcile them

    • Saved queries — list_saved_queries and get_saved_query open your Query Studio library (yours, plus pipeline or team queries shared with you) with the same visibility as the Saved Queries page; run them with execute_sql

    • PII and docs — classify_table and classify_schema return PII labels only, never raw cells; search_documentation keeps the agent from inventing docs that are not there

    • AI agents — publish skills, start runs of published agents, and search the Enterprise brain

    Query Studio — MongoDB in your dialect, whole rows from the grid

    • MongoDB query mode — a JSON query object, a mongosh-style command, or SQL that Core Hub translates into an aggregation. Read-only, offsets on the server, data-access policies matched by collection (including ones a $lookup, $graphLookup, or $unionWith pulls in), and cancel actually stops the in-flight job

    • Add row and Delete row — right in the result grid, under the same gate as cell edit (Writable mode, a single-table result, a discovered primary key; not on MongoDB). Add row opens a modal with a NULL checkbox per column; Delete row asks first and matches by primary key. Both run as a parameterized INSERT / DELETE through the existing execute route, so permissions, audit, and history apply unchanged. See Inserting and deleting result rows

    • Primary-key edits across foreign keys — the UPDATE temporarily relaxes the constraints that block it (SQL Server, MySQL / MariaDB / SingleStore, Oracle, Db2 LUW), then turns them back on in the same transaction; a failed write rolls everything back. Oracle inside a manual transaction is refused on purpose: DDL there auto-commits

    Same workbench. The editor stays for the queries that deserve it.

    Data governance — PII labelled everywhere, access scoped per connection

    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.

    • PII discovery and masking — columns that look like PII are classified (name first, sample scan when you ask), tagged in Query Studio and the Fields Editor, and masked in the grid, copies, and exports. Multilingual aliases and checksum rules (CPF, Aadhaar, Chinese resident ID, South African ID, TCKN, NIF/NIE, NIR, TFN, and more) make the classifier global rather than English-only. Managers and super admins can reveal values for one session; super admins can turn platform-wide Query Studio masking off (it stays on unless they do). AI Studio and MCP execute_sql stay masked either way

    • Connection-scoped data access — super admins set a per-user, per-connection matrix, OPEN or RESTRICTED, with schema and table ALLOW/DENY rules (deny wins) and optional PII unmask grants down to a column. The same guard covers Query Studio, AI SQL, and MCP/Spark SQL, without new UserRoles

    • Custom templates — save a named template (analyst, auditor, whatever your org calls it) next to the built-in Viewer and Manager ones and apply it to replace a user’s policies in one shot

    Connectors — ClickHouse, self-enabling SQL Server CDC, and better streaming payloads

    • ClickHouse target — ClickHouse does not do cheap row updates, so the new target-only agent writes every change as a new version of its key into a ReplacingMergeTree(_version, _is_deleted) table Gluesync generates for you: multi-row INSERT … VALUES batches over HTTP/S JDBC, deletes as tombstones, and Query Studio / the Validator read with final = 1. User-owned tables of another shape fall back to append mode with a warning. Full Gluesync type coverage

    • SQL Server automatic CDC / Change Tracking activation — both SQL Server sources can enable capture themselves (database, tables, and the recursion-protection sidecar) when you tick "Enable automatic Change Data Capture / Change Tracking activation". It is off by default: left off, setup posts a warning with the exact statements to run by hand; turned on, a failed enable throws with the statement and the server error

    • Streaming before-image — set includeBeforeImage on a Kafka, Solace, or Google Pub/Sub target and updates carry the prior column values in before. Leave it off and payloads stay byte-identical. Pub/Sub also picks up the shared transaction id the other brokers already carried

    • IBM i — two entities reading the same physical file no longer overwrite each other’s column attributes: each keeps its own types, precision, and CCSID at decode time

    Data Validator and operations — prove it matches, alert only when it is broken

    • Data Validator — replication saying "caught up" and the rows actually agreeing are not the same question. The Validator runs an asynchronous, cancellable comparison per entity: ordered keyset scans on both sides, merge-joined in Core Hub on dedicated read connections, with persisted schema and row differences, live progress, and optional whole-run reconciliation. Start it from the Control Plane, MCP, or a Chronos Validate action. Run it after lag is gone or in a quiet window — it is not a frozen snapshot of both databases. See Validator

    • Smart alerts v2 — learns each entity’s actual cadence before calling anything inactive: sparse entities stay quiet, heartbeat liveness stays an independent signal, the overlapping target-side stall alert is off, and baselines survive a Core Hub restart. algorithmVersion: 1 keeps the legacy path. See Smart alerts

    • Clear Logs — empty Core Hub’s own log files and rolled archives without stopping the process (POST /global-config/support/clear-logs), optionally sweeping support archives too. Clear, reproduce, collect: the bundle you send us is finally all signal

    Additional improvements