November 13, 2026: Ora
✨ Ora
Ora can now work from Excel and Word files you attach to a chat, point a Celigo Sync at Amazon Redshift, and tell you whether an error belongs to a past Celigo-wide incident. You can ask Ora to reset multi-factor authentication for a user you name, stage the removal of a mapping row condition or a lookup entry on an approval card, and get your account's current data summarized alongside the built-in dashboards. Error diagnosis gained live connection checks, analysis of errors whose category label is incorrect, clearer retry results, and diagnosis from an error you paste in on its own. There are no breaking changes in this period.
Talk to Ora your way
- Excel and Word attachments: Attach an Excel (.xlsx) or Word (.docx) file to a chat, and Ora reads it and works from its contents. The chat declines the older .doc and .xls formats at upload and names the format to save the file as.
Expanded platform coverage
- Amazon Redshift as a Celigo Sync destination: Ask Ora to point a sync at your Amazon Redshift cluster, and Ora stages one destination card with the Redshift connection, the schema you named, and the database the connection already carries. Ora tells you what it covers, including provisioned clusters and either IAM role or password authentication, and what it does not, including agent connections and Redshift as a source. A schema name Redshift rejects, a database other than the connection's, and a connection that runs through an on-premise agent are all caught before a card is staged.
Diagnose and fix errors
- Incident awareness: Ask Ora whether a Celigo-wide incident happened on a given date, for example “was there an incident on November 4?” Ora also recognizes an error as part of a past incident days later and answers with Celigo's published guidance, and it reads a connection error that arrives in a burst, or as a rare trickle beside a working flow, as a sign that your own setup is not the cause and that a retry is the first step.
What Ora knows about your account
- Dashboard requests: Ask Ora for a dashboard, and it points you to the built-in live dashboards in integrator.io and summarizes your account's current data in the chat. Ora also tells you that custom saved dashboards are not available, so you know where the built-in views stop.
How Ora keeps changes safe
- Condition and lookup removals: Ask Ora to remove a condition from a mapping row, or to remove a single lookup entry, and review the change on an approval card before it is applied.
Managing users and account access
- Reset multi-factor authentication: As an account owner or administrator, ask Ora to reset multi-factor authentication (MFA) for a colleague, and Ora stages that reset for your approval. Ora identifies the right person, whether a workspace user or an end user, and asks which one you mean when two users share a display name. A user who signs in through your company's identity provider is reset in that provider. Because MFA is required on paid accounts, a request to turn MFA off gets you the reset path instead.
Improvements
- Errors with an incorrect category label: Previously, Ora read an error through the category the platform assigned to it. Now, Ora analyzes the error from its message, step, connection, and record, and tells you when the category label is incorrect. For example, Ora explains “Expected field: refreshMethod to be present.” as a token connection with no saved token.
- Live connection checks during error diagnosis: Previously, Ora diagnosed a connection error from the failed record. Now, when Ora's own live check fails the same way the record did, Ora tells you the connection is being refused right now, tests it, and proposes the retry. When a record failed and then went through, Ora explains what changed in between.
- Errors in Celigo-owned screens: Previously, Ora treated an error on an integrator.io page or an Integration App page as something to debug in your browser. Now, Ora tells you the error is Celigo's to fix, says what still works, and hands you a ready-to-paste Support ticket.
- Retry results: Previously, Ora reported a retry as a single outcome. Now, Ora reports a retry by where its records ended up, whether they landed, failed at a later step, or were set aside, so a bulk retry that clears the source step and fails at the import is not reported as a success.
- Connection offline diagnosis: Previously, Ora reported that a connection had gone offline. Now, Ora explains that any connection test can mark a connection offline, including an API ping that times out, and tells you when a monitor is pinging the connection on a schedule.
- Support case formatting: Previously, Ora wrote a support request as one block of text. Now, Ora gives you the two blocks the Support form takes, Subject and Description, ready to paste.
- Duplicate record tracing: Previously, Ora confirmed that a record had been written twice. Now, Ora lists every flow that writes that record and names the run that wrote the copy.
- Error diagnosis from a pasted error: Previously, Ora diagnosed an error from the flow step it came from. Now, you can paste an error message on its own, without naming a step, and Ora analyzes it using what it knows about each application you name.
- Retry guidance: Previously, Ora explained where a retry resumes for some stages of a flow run. Now, Ora explains it for every stage the platform records: an error in a source export's transform, output filter, or pre-save hook is retried at that part, on the saved record, and the source is not read again. A retry on a Transform 2.0 error is flagged as a reported platform defect that skips the transform, along with the route that avoids it.
- Fields an integration app manages: Previously, Ora offered to change a field on an integration app's step, such as a relative URI, a connection, a hook, or a transform. Now, Ora tells you first that the app manages that field and that an edit will not take effect, then offers a custom flow alongside the app or a feature request.
- Integration lifecycle pulls: Previously, Ora ran a pull into a lifecycle-linked clone as you asked for it. Now, before the next pull, Ora names the limitation on multi-instance flows and the preparation it needs: choose the customizable properties again on the clone's base flow, set up its instances, then pull. When a pull fails, Ora's plan comes with the choices for that pull, which are to revert to the snapshot, create a fresh linked clone, or open a Support ticket.
November 11, 2026: Ora
✨ Ora
Ora now works with the Marketplace's Ora guided templates: it can name them, open the filtered view, and install the template you choose from a tile. You can also ask Ora whether a connection's automatic token refresh is working, whether Celigo connects two specific apps, and how your Ora credits work. Error diagnosis now takes recent changes to upstream steps into account, and settings form approvals stop short of saving a form the platform does not accept.
Find and install from the Marketplace
- Ora guided templates: Ask Ora which templates it can install for you, and it lists the nine templates that carry the Ora guided badge and explains what the badge means. Ask Ora to take you to the Ora guided templates, and it opens the Marketplace on the By type → Ora guided view.
- Install from a Marketplace tile: Select Install on a Marketplace tile, and that template is handed straight to Ora. Ora asks its one setup question and installs the template you selected, even if you move to another tile's preview while you answer.
- Connections for MCP server tools: When you install a Model Context Protocol (MCP) server from a Marketplace template, Ora's readiness check names each tool still bound to the template author's connection. Ask Ora to apply your connection to every tool, and it rebinds them all in one step.
Diagnose and fix errors
- Connection token refresh: Ask Ora whether a connection's automatic OAuth token refresh is working, and it answers from the connection's change history and a live test.
Answers about Celigo and Ora
- App pairing answers: Ask from the home page whether Celigo connects one app to another, and Ora answers from the Marketplace catalog.
- Ora credits: Ask Ora about your credits, and it explains how automatic refills work on a paid plan, why a long conversation uses credits faster, and what you can change. When your account runs out of credits, Ora tells you directly.
Improvements
- Approval cards: Previously, Ora offered an approval card for every settings form rewrite it produced. Now, when a rewrite would leave the form in a state the platform does not accept, Ora stops and names what is missing instead of offering the card, and a rewrite that would drop one of the form's existing dropdowns keeps the stored one and says so.
- Error cause and onset: Previously, when a group of errors had no matching edit on the failing step, Ora reported that no change was on record. Now, Ora also reads recent changes to the steps that feed the failing step and dates the group to the day its errors became frequent, so a change to the source query or saved search is named as the cause.
- Pasted errors: Previously, Ora asked you for an identifier to locate an error message you pasted. Now, Ora searches your account for the flow and step that raised it, and asks for an identifier only when the search finds nothing.
November 9, 2026: Ora
✨ Ora
Ora can now manage end-user access to your Model Context Protocol (MCP) servers from chat, including end-user roles, role assignments, and multi-factor authentication (MFA) resets, each staged as an approval card you review first. You can also ask Ora to download a file or a folder that already lives in integrator.io File storage, and it arrives as a card in the chat. Files Ora writes for you now arrive the same way instead of going to File storage, a breaking change for anyone who counts on finding those files there. Ora also handles error diagnosis, questions about Celigo Support response times, and Sandbox testing differently this period.
Manage end-user access from chat
- End-user roles and MFA: You can ask Ora to create, change, or delete an end-user role, which is a named bundle of MCP server grants, put a role on an end user or a group, and reset an end user's multi-factor authentication (MFA). Each change comes to you as an approval card before it takes effect. For an end user who signs in through an identity provider, Ora tells you the MFA reset happens at the identity provider instead of staging one.
Get your files from the chat
- File storage downloads: You can ask Ora to download a file or a folder that already lives in integrator.io File storage, and it arrives as a card in the chat with the file name, size, and a Download button. A folder arrives as a single zip file. The download link is signed when you select Download, so no link sits in the chat.
Improvements
- Error diagnosis: Previously, when the words you used to describe a failure matched no error message in your account, Ora asked you for a screenshot of the failure. Now, Ora lists the flows that hold open errors, newest first, and reads the failing flow's error itself. When Ora can't locate an error you asked about, it checks the integration or flow you named before asking you for an identifier.
- Support response times: Previously, asking how quickly Celigo Support would respond returned a table of the support plans and their response times. Now, Ora answers from your account's own support plan, and it does so from any page.
- Sandbox testing: Previously, on accounts that use the Production and Sandbox toggle, asking to try a change in Sandbox first pointed you to Celigo Support. Now, Ora gives you a plan: test the change through the toggle, then Ora reads the production flow as the reference and stages the production change for your approval.
Breaking changes
- Where Ora puts the files it writes: Previously, a file you asked Ora to create, such as a markdown summary or a CSV of errors, was saved to integrator.io File storage. Now, the file arrives as a card in the chat with its name, size, and a Download button, and it goes to File storage only when you name a location, for example "create notes.md in my Reports folder". Action required: To keep a file in File storage, name the folder when you ask Ora for the file, or ask Ora to save the file to File storage after the card appears.
November 6, 2026: Ora
✨ Ora
This period's changes are about how Ora reads a flow run that has stalled, how it explains a connection that goes offline, and how it stages lookup table edits for your approval. Ora can now tell a slow run from a frozen one and offer to cancel and rerun as soon as it confirms the run is stuck. When a connection goes offline, Ora points at the flow run that was in progress at that moment and the step error behind it.
Improvements
- Stuck and frozen flow runs: Previously, Ora read a started run's counters as progress and waited for the platform's four-hour mark before offering to cancel the run. Now, Ora checks whether records have actually moved, compares the run with that flow's own recent runs, and tells you when there's too little history to judge. Once Ora confirms across two checks that a run is frozen, it offers to cancel and rerun right away. A connection in rate-limit recovery is reported as the platform pausing on purpose, and earlier runs that someone stopped by hand are reported as history rather than a cause.
- Offline connection diagnosis: Previously, Ora explained a connection that went offline from the connection's own records. Now, Ora also finds the flow run that was in progress at the moment the connection went offline and quotes the step error that tripped it, and it reads an outage that lasts for days as an expired credential rather than a brief interruption.
- Lookup table edits: Previously, adding one row to a lookup table staged a rewrite of the whole table on the approval card. Now, the card carries only the rows you asked Ora to change and leaves the rest of the table as it is.
November 5, 2026: Ora
✨ Ora
Ora can now trace account-setting changes in the audit log, apply a network policy to a webhook or a real-time listener, and control whether an API fails right away when one of its connections is offline. Ora also explains offline-connection failures in more detail, and it generates JSON and XML file templates that don't loop over records.
Keep your account secure
- Audit log answers for account settings: You can ask Ora who changed an account setting, including company and end-user multi-factor authentication (MFA), API Management setup, execution logging, AI settings, the account alias, the API Builder timeout, and a member's access. Ora answers with who made the change, when, where it was made, and which fields changed. When a question is too broad to answer from the audit log, Ora tells you how to narrow it instead of answering from sign-in records.
- Network policies for webhooks and listeners: You can ask Ora to put a network policy on a webhook or a real-time listener, or to remove the restriction, and review the change on an approval card before it's saved. Ora counts listeners when you ask what a policy protects, and it explains the 403 access denied response a delivery gets when it arrives from an address outside the policy's lists.
When an API connection goes offline
- Immediate error for offline connections: The APIs Ora builds now turn on the Immediate error for offline connections setting, matching the default integrator.io gives a new API. You can also ask Ora to turn the setting off or back on for an API you already have, and Ora stages that as an update card with nothing else in the change.
Improvements
- Offline connection diagnosis: Previously, Ora explained a request that failed while a connection was offline as a timeout. Now, Ora names the offline connection and the setting behind the response, whether that's an immediate 500 error or a 504 timeout after 2 minutes, and tells you whether any step ran. Ora gives you the options: bring the connection back online, turn the setting on for an immediate error, or leave it off to ride out short outages. A test run from the builder also tells you what callers would see during an outage, because test runs aren't subject to the setting.
- File templates without a record loop: Previously, Ora included a record loop in every JSON and XML file template it generated. Now, when the template body reads no record fields, a per-page count summary for example, Ora generates the template without a loop and passes along the editor's warning that the template won't loop over records. A record field used outside a loop is still reported as a defect, with the fix named.
November 4, 2026: Ora
✨ Ora
Ora now answers questions about five more areas of integrator.io: the Celigo Storage activity log, SSH File Transfer Protocol (SFTP) account access, electronic data interchange (EDI) order tracking and log search, Model Context Protocol (MCP) server templates and uploads, and the API Management console. You can also ask Ora to build an import hook and test it against a real response from your destination. Error diagnosis changed in several ways: Ora recognizes records that a retry already processed, checks whether a published fix applies to your own record before relaying it, reads past a capped result rather than reporting the remaining records as missing, and commits to a most likely explanation when the decisive detail sits somewhere it cannot read.
Expanded platform coverage
- File storage activity: Ask who uploaded, changed, or deleted a file in Celigo Storage, and Ora reads the storage activity log and tells you who acted, what they did, when, over which channel, and from which IP address. You can filter by file, person, channel, action, or time window, and when nothing was recorded in the window you asked about, Ora tells you that rather than reporting the question as unsupported.
- SFTP account access: Ask how a trading partner signs in to your file server and what it may do, and Ora reports whether the account uses a password, an SSH key, or both, each key's label, fingerprint, and algorithm, and its Read, Create, Modify, and Delete permissions. Ora reads this information only, so every account, permission, and key change still happens in the account's drawer.
- EDI order lifecycle and log search: Ask whether a purchase order has shipped and been invoiced, which orders are still at the purchase order stage, or what matches a keyword anywhere in the EDI log, and Ora answers from the platform's own order grouping and lifecycle stage. Filters by trading partner, lifecycle status, document type, direction, and functional acknowledgment status run across your whole retained history.
- MCP server templates and uploads: Ask what a Marketplace MCP server listing ships, and Ora reads its capability sets, APIs, resource files, proxied upstream servers, end-user credential requirements, and rate-limit policies. After an install, Ora lists what is still to do, including the Access tab grants that capability sets need before anyone can call the server. Ora also walks you through Upload MCP when a colleague sends you a server's exported package.
- API Management answers: Ask about the API Management console, its roles, developer portal registration and approval, or plans and subscriptions, and Ora answers from curated knowledge of what your console exposes, then tells you what to check there before routing anything else to Celigo Support.
How Ora keeps changes safe
- Import hooks built from a real response: Ask for a hook that reacts to what your destination replied, such as treating a specific error as a success or stripping a field from the response before the next step, and Ora writes the hook and tests it against a real reply. Ora uses a live test send when you approve one, or a reply captured in an earlier run's logs or one you paste, and it tells you which reply it used. When no real reply is available, Ora says so and offers both ways forward.
Improvements
- Retries and duplicate records: Previously, a record that failed again during a retry was reported as a new failure. Now, Ora checks whether each re-failure is a second copy of a record the same retry already wrote successfully, explains it as already processed with the destination record as proof, and offers to retry only the rows that were missed.
- Outage checks: Previously, when you asked whether an application was down, Ora drew on that vendor's public status page. Now, Ora checks whether errors involving that application are spiking across other accounts in the same region and whether Celigo has published an incident, and because Ora treats your account's region as a known fact, it tells you whether a region-specific incident affects you.
- Where a step gets its data: Previously, Ora answered a question about a step's saved search, query, or data source from that step alone. Now, Ora traces the records back through the flow, names the source step and what it reads, and says plainly when nothing in the flow uses one.
- Documented fixes checked against your records: Previously, Ora relayed a published fix whenever the error matched it. Now, when a fix applies only under a condition, Ora reads your live record first and says so when the condition does not hold, instead of presenting the fix as the answer.
- Diagnosis when the evidence runs out: Previously, when the decisive detail sat somewhere Ora cannot read, Ora listed what it had found and pointed you to Celigo Support. Now, Ora states its most likely explanation, labels it as such, and names the one check that would settle it.
- Support tickets: Previously, a ticket drafted after you asked for a human carried the findings Ora had at hand. Now, Ora first runs the reads it can make in your own systems, and the ticket carries those findings along with Ora's verdict of confirmed, most likely, or open.
- Complete live reads: Previously, when Ora read records from a live system and the result filled the limit it asked for, records beyond that limit were reported as missing. Now, Ora recognizes a capped result, reads the rest before drawing a conclusion, and says when a result shows fewer records than the system returned. Follow-up analyses in the same conversation also carry forward what an earlier analysis ruled out.
- Integration app release rollout: Previously, when you asked about a feature described in your integration app's release notes, Ora confirmed the feature and helped you trace a record. Now, Ora checks when Celigo's last update reached your install, and when the release has not landed yet, it tells you that Celigo rolls it out and which setting will appear when it does.
- Product questions passed to Celigo: Previously, asking Ora to relay a product question to Celigo recorded the question as feedback. Now, Ora looks the question up first and leads with the documented answer, then passes on what remains.
November 2, 2026: Ora
✨ Ora
Ora can now build AI agents on more model providers, including AWS Bedrock, Azure OpenAI, and Vertex AI, and add Code Execution to an agent that runs on your own provider key. For Model Context Protocol (MCP) servers, Ora hands you one registry address that lists every server your credential can reach, and builds Tools that filter what they return by who called them. Ora also understands on-premise agent groups, reading a group's live health and managing it through approval cards.
Build AI agents on the provider you choose
- AI agents on more model providers: You can ask Ora to create an AI agent on any model provider integrator.io offers, including AWS Bedrock, Azure OpenAI, Vertex AI, Together AI, Fireworks AI, NVIDIA NIM, and Ollama Cloud. Most of these providers run on a connection you own, so Ora asks which connection to use before it saves the agent, and for the AWS Bedrock (Agents) and Azure OpenAI (Agents) connectors it builds the endpoint from the region or resource name you give it. When you name a provider the platform does not offer, Ora tells you which ones are available instead of creating the agent on a different one.
- Code Execution for AI agents: You can ask Ora to add Code Execution to an AI agent so the agent can compute results as part of its work. Ora adds the tool when the agent runs on your own OpenAI, Anthropic, or Gemini connection and the model supports it, and tells you what you get: the provider's sandbox with no outbound network access, files in and out in the agent trace, and usage billed as AI Actions to your provider account rather than Celigo AI credits. When the agent runs on Celigo AI credentials, or on a model without support for the tool, Ora says so and asks whether to move the agent to your own connection or leave the tool out.
- Moving an agent to another provider: You can ask Ora to move an existing AI agent to a different provider. Because the platform stores each provider's agent in its own format, Ora rewrites the agent in full for the new provider and removes the old definition, and it describes the rewrite before you approve it.
Get more from your MCP servers
- One address for all your MCP servers: You can ask Ora where to point an AI agent, script, or catalog so it finds every MCP server in your account, and Ora gives you the account's registry address next to the server address. What a caller sees depends on the credential it uses: every enabled server for a full-access token, the selected servers for a custom token, and the granted servers for a sign-in. The registry is a list of servers rather than an MCP server itself, so you don't add it to a client such as Claude or Cursor.
- Tools that know who called them: You can ask Ora to build a Tool that answers questions about the caller's own data, such as a Tool that returns only the tickets belonging to whoever called it. Ora explains the three ways a Tool can do this — a scoping input the client passes, end-user credentials so the Tool runs as the caller, or the caller context, where the Tool runs on the administrator's login and knows who called — and builds the one you choose. In caller-context mode, Ora filters on the caller's email everywhere the step uses a value, including the query, address, header, body, a Mapper 2.0 mapping, a transformation, and a filter rule, so a call that carries no caller matches nothing. Hooks and scripts on the Tool can branch on the caller as well.
Keep on-premise connections running
- On-premise agent groups: You can ask Ora about an agent group, and it explains how the group works: an ordered failover list rather than load balancing, which member is serving the connection, and why a member is skipped, such as a stale heartbeat, a stopped worker, a member that is draining, or a pairing that never finished. Ora reads a group's live health member by member, and creates, updates, and deletes groups through approval cards. A connection binds to a group or to a single agent, never both, and Ora checks your entitlement and the group before it stages a card.
October 30, 2026: Ora
✨ Ora
Ora can now work across your whole account at once: ask which flows a given error is hitting, then retry, resolve, assign, or tag every one of them in a single request. When a question needs data Ora's built-in tools don't return, Ora reads the public Celigo API directly and can run its own read-only code to compare large sets of results. You can also set up rate-limit detection on a connection by describing how the API signals throttling. Approval card summaries, webhook listener setup, Celigo Support ticket drafts, and answers about security advisories all changed this period. There are no breaking changes this period.
Errors across your whole account
- Account-wide error search: You can ask Ora which of your flows are hit by a given error and get the breakdown by integration, flow, and step, including how many errors there are, how long they have been running, and what they say. Ask from the home page, the dashboard, an integration, a flow, or an errors page, and filter by error code, classification, message text, or time window. Ora tells you when an account is too large to cover in full.
- Account-wide error cleanup: You can ask Ora to retry, resolve, assign, or tag every error that matches a description across all of your integrations. Ora stages one approval card per affected step, up to 1,000 at a time, and you accept them together. You can then ask how the retries went and get the number of jobs that finished, the number of records that went through, and the flows that still have failures.
When Ora needs more than its built-in tools
- Direct Celigo API reads: When your question needs data that none of Ora's built-in tools return, Ora reads the public, read-only parts of the Celigo API to answer it, for example to tell you which flow kicks off another flow.
- Code-backed analysis: Ora can write and run its own read-only code on Celigo's script runtime, the same sandbox your flow scripts use, to join, filter, and compare large sets of data it has already pulled. Nothing is written to your account.
Setting up connections
- Rate-limit detection: You can describe how an API signals that it is throttling you, either as a value at a path in the response body or as the presence or value of a header, and Ora stages the detection rule as a single connection save. Ora tells you that it has not tested the rule against the API, and it can remove the rule as cleanly later.
Improvements
- Approval cards: Previously, the summary on an approval card was written by the agent that staged the change. Now, Ora builds the summary from the change's actual before-and-after difference, for every agent, so the summary matches what the card applies.
- Webhook listeners: Previously, asking Ora for a listener that receives events from a provider such as Slack, Shopify, or GitHub produced a listener built on a placeholder connection. Now, Ora creates the webhook listener itself with the provider's signature verification already set, and the signing secret is the one thing you paste into the form, since Ora never asks for it in chat. The same applies when the listener is the first step of a flow you ask Ora to build, and a custom listener with no provider always gets a verification method.
- Celigo Support ticket drafts: Previously, a Support ticket Ora drafted could carry a fix or a timeline that Ora inferred from the problem. Now, the draft quotes what Ora's research found, with the source and the date.
- Security and vulnerability questions: Previously, Ora answered a question about a published security vulnerability from a web search. Now, Ora answers from Celigo's own security advisories, and it no longer offers to open a case it cannot file.
October 29, 2026: Ora
✨ Ora
Ora can now work with the request log on a Model Context Protocol (MCP) server: reading what a client called, changing the log mode, starting a timed debug window, purging stored payloads for a time range, and opening the run trace of a Celigo Tool call. This period also carries a wider than usual set of improvements, covering account invitations, integration app uninstalls and store uninstalls, install and settings troubleshooting, error actions across a whole flow, mapping format changes, and finding your sandbox. There are no breaking changes this period.
See what is calling your MCP servers
- MCP server request log: Ask Ora what a client called on an MCP server and it reads the server's request log with the capability on every row, including the tool, prompt, or resource name and its kind, whether a payload was stored, how long the call took, and which token or login made it. You can filter and group the log by capability, and when a row has no stored body, Ora tells you which log mode left it out.
- Log modes and debug windows: Ask Ora to set a server's log mode to No logging, Basic, Standard, or Detailed, or to start a timed debug window on top of the current mode. Ora checks your account's Store payload setting and your plan's limits first, then stages the change as an approval card and applies it when you accept.
- Payload purges: Ask Ora to purge a server's stored payloads for a time range. Ora stages the purge and says up front what goes, the stored request and response bodies and the Tools run logs in that window, and what stays, the rows showing who called, when, which capability, and the outcome.
- Run logs for a Celigo Tool call: From a row in the request log, ask Ora to open the run logs and it brings up the step-by-step trace for that call.
Improvements
- Integration app settings in a diagnosis: Previously, when a diagnosis pointed at an integration app setting, Ora named the setting for you to check. Now, Ora reads that setting's current value, tells you what it is and what to change it to, and carries the value into the Celigo Support ticket it drafts.
- Checking that a fix worked: Previously, Ora confirmed a correction by retrying the failed record. Now, when the correction applies earlier in the flow, Ora runs the flow again so the change is exercised, and when a retry fails a second time, Ora tells you whether the error is the same one or a different one.
- Integration app install troubleshooting: Previously, a template connection that had not been authorized yet was reported as expired credentials. Now, Ora reads it as an install step that is not finished, shows which install step each connection in the integration belongs to and whether it is done, and leads with the exact choice to make when an install wizard's connection step keeps returning you to the start.
- Setting changes staged for approval: Previously, Ora staged an integration app setting change from your request. Now, Ora first checks what the app documents about that setting, including which settings cannot be used together and which flows use it, names the value it is replacing so a change you made as a test can be undone, and says what stops working when a change clears a configured value. When the analysis calls for a check first, Ora runs that check before it stages anything.
- Errors across a flow: Previously, asking Ora to retry, resolve, assign, or tag the errors in a flow from a step's error page covered the step you were on. Now, Ora covers every step in the flow that has errors, with one approval card per step naming its error count, and points you to the step that holds the errors when the step you are on has none.
- Suspected defects and product feedback: Previously, Ora recorded a reported defect as you described it. Now, when Ora's own analysis traces the failure to your configuration, it records the report as suspected rather than confirmed, says what would settle the question, and makes clear that the record is product feedback rather than a Celigo Support ticket. Asked whether something should have worked, Ora checks the documented behavior before it answers, and tells you when the behavior is not documented.
- Mapping format changes: Previously, Ora described a mapping edit that moves an import to Mapper 2.0 as something it could undo. Now, Ora tells you before you approve the edit that the move to Mapper 2.0 is one-way.
- Removing an integration app: Previously, a request to remove an installed integration app returned the app's own accounts and connections as items to clear first, each offered for deletion. Now, Ora identifies the installed app and points you to the Admin uninstall pages in the order to use them, child accounts first and then the app, with how to reach each page and who has permission to run the uninstall.
- Finding your sandbox: Previously, asking where to find your sandbox returned a description of the environment switcher. Now, Ora reads your account first and answers for what it finds: the named sandbox and how to reach it, the legacy production and sandbox toggle, or that your plan includes a set number of environments and none is set up, with an upgrade request as the next step. An environment that is turned off because the account is at its plan limit is described as such, rather than as something an admin can turn on.
- Account invitations: Previously, a question about which accounts your login belongs to, or about an invitation you could not see or accept, returned a pointer to the admin Invitations settings page. Now, Ora reads your own memberships and pending invitations and names the reason an acceptance is blocked, which is that the platform refuses it while your own account still owns integrations, flows, or syncs, including the sample integration a free trial starts with, and it tells you what to transfer or delete first. Once your account is clear, Ora stages the accept or the dismiss as an approval card in chat.
- Store uninstalls in multi-store integration apps: Previously, a request to remove one store from a multi-store integration app returned the app's uninstall page and a reminder to select the right store. Now, Ora points you to that store's own uninstall page, starting with the store on your screen, and explains that uninstalling the last store removes the app itself, so there is no separate step for the app. When a store uninstall returns an error, Ora checks the connection named in the error, including whether it is offline and whether leftover steps still use it, and reports what it verified with the status code as the open question.
October 28, 2026: Ora
✨ Ora
You can now ask Ora to run a flow for a date range you name, so a specific window gets reprocessed without touching the flow's schedule. Troubleshooting carries the rest of this period: Ora diagnoses why a real-time flow missed records, explains why a connection went offline and came back on its own, keeps an error analysis going when a hook's script cannot be read, hands you what a long record investigation found, and knows which environment each chat is working in. One breaking change this period: self-service Shopify connections now use a Shopify app you own, and you need to move them before Celigo's public app fallback ends in mid-December 2026.
Run your flows from chat
- Run a flow for a date range: Ask Ora to run a flow "from August 22" or "for the first two weeks of August," and it runs the flow's incremental sources for exactly that window. Ora tells you where the next scheduled run picks up afterward, which is the end of the window you asked for, as long as that run exported records.
Improvements
- Real-time flow troubleshooting: Previously, when a real-time flow missed some records, Ora proposed rebuilding it as a scheduled flow. Now, Ora checks the listener's own conditions, including whether it is registered and active and whether the record qualifies, and proposes a targeted fix such as turning the listener back on or adjusting the criteria. Ora also knows how NetSuite, Salesforce, and webhook listeners decide whether to fire, so it can answer why a flow did not run.
- Connection health diagnosis: Previously, when a connection went offline and came back on its own, Ora described the cause as a question for Celigo engineering. Now, Ora explains what happened: the app rejected the connection's credentials, so the platform paused the connection's flows and retested the connection until it passed. Ora also points you to where the triggering error is recorded, in the step's error or the app's own sign-in log.
- Error analysis when a script can't be read: Previously, when Ora could not open a hook's script, because the code belongs to an integration app or your permissions don't reach it, the analysis stopped and asked you to check whether you were working in production or in a sandbox. Now, Ora diagnoses the error from the evidence it does have, including the error itself, the run history, and the configuration, and tells you when the script belongs to the app rather than to your account.
- Record investigations: Previously, when tracing a record through a flow run reached the limit on how much Ora can do in one reply, Ora returned a processing-limit message. Now, Ora reads each step's data in a single pass so it reaches an answer more often, and when it does reach the limit, it writes up what it found so far and tells you the investigation was cut short.
- Environment awareness: Previously, Ora worked out which environment a chat was running in as it went, and asked you whether your account uses named environments or the legacy production and sandbox toggle. Now, Ora is told at the start of each chat which environment it is working in, so a sandbox session is read as a sandbox, and a request to move work to production or to connect to a sandbox is answered for your account's actual setup.
Breaking changes
- Shopify connections on your own app: Previously, a self-service Shopify connection used Celigo's public Shopify app, and Ora answered that no iClient was needed. Now, a self-service Shopify connection uses a Shopify app you own, and Ora gives you the steps in place: create the app in the Shopify developer dashboard, register its client ID and secret as an iClient, set the connection's App type to Custom App, then Save & authorize. The same connection is re-authorized, so nothing is re-pointed. You can also ask Ora to stage the change for you. Celigo's public app stays available as a fallback until mid-December 2026, and integration app connections are not affected. Action required: move your self-service Shopify connections to a Shopify app you own before mid-December 2026. Integration app connections need no change.
October 26, 2026: Ora
✨ Ora
Ora can now read and change the long-run alerts on an integration's Alerts tab, explain why a scheduled flow missed runs on a past day, and tell you which of your AI agents are on a model that is being retired. Improvements cover the start time a scheduled flow actually gets and the model you pick when you build an AI agent. There are no breaking changes this period.
Know when a flow runs long
- Long-run alerts: Ask who gets alerted when a flow runs long, whether a flow has a run-time limit, or what long-run alerts an integration has, and Ora reads the integration's Alerts tab and lays them out: the scope, the limit, the recipients, and when each one last fired. For the flow you asked about, Ora says which rule applies, whether that is the flow's own limit, the integration-wide default, or none. You get the same answer from the flow page, the dashboard, Error Management, or home.
- Changing long-run alerts: Ask Ora to add, change, or remove a run-time limit on a flow, or to add or remove a recipient across an integration's alerts, and Ora stages the change as an approval card. Ora edits an alert that already exists rather than creating a duplicate, tells you what covers a flow after a limit is removed, and lists any alert it cannot change because the person you are removing is its last recipient. A recipient must already be an account user with access to the integration, and your own permissions apply when the card is accepted.
See what your flow's schedule actually did
- Missed runs on a past day: Ask why a scheduled flow missed runs yesterday, or on another recent day, and Ora compares that day's run history against the schedule that was in force at the time. Ora tells you how many runs were expected, how many happened, and what caused each gap, whether that is a run that hung and held up the schedule, a wait in a connection queue, the flow being turned off, or a run the scheduler missed, along with any manual catch-up that followed. When Ora can only compare against today's schedule, it says so.
Keep your AI agents on supported models
- Model health for AI agents: Ask whether a model is still supported and Ora gives you that model's standing, its retirement date, and the replacement Celigo suggests. Ask which of your AI agents need attention and Ora lists them, the most urgent first, each with its suggested replacement. On a connection that authenticates with an API token, Ora answers from the platform's model-health information and tells you what that connection can and cannot report.
Improvements
- Flow start times: Previously, a request to run a flow at an exact minute produced a schedule set to that minute. Now, Ora explains that Celigo spreads start times across the platform, so you choose the cadence and Celigo picks the minute, names the time the flow will actually run, and offers the nearest available time or an API-triggered run when the exact minute matters.
- Models when you build an AI agent: Previously, a request for an AI agent or guardrail on a model the platform does not offer was built on the provider's default model. Now, Ora stops before saving, explains in the platform's own words why that model is unavailable, and lists the models Celigo suggests so you choose the replacement. A model scheduled for retirement is built as you asked, with its retirement date and recommended replacement included, and a run blocked because its model is retired is explained as a model to change rather than a provider outage.
October 22, 2026: Ora
✨ Ora
Ora can now retrieve the raw file behind an electronic data interchange (EDI) document, along with the acknowledgement your trading partner returned for it, and answer your questions from what those files contain. Looking up a document by its number is more precise as well, so a number shared by several documents no longer sends you to the most recent match by default. There are no breaking changes this period.
Work with EDI documents and acknowledgements
- EDI file and acknowledgement retrieval: Ask for the file behind an activity log row, or for the acknowledgement a trading partner returned for a specific document, and Ora retrieves it, reads it, and answers from its contents, down to the individual error segments of an acknowledgement that reports errors. You get the same answer in a signed-in chat and when you reach Ora with an API token, and Ora tells you when a file was too large to return in full.
Improvements
- EDI document lookup: Previously, when several documents shared a document number, Ora returned the most recent match. Now, Ora narrows the search with the details you give it, including direction, sender or receiver ID, integration, and whether the document is in a sandbox. Ora tells you when it picked the most recent of several matches, and suggests a filter when you have not given one.
October 21, 2026: Ora
✨ Ora
This period's changes are about what Ora tells you: what your account is entitled to, what it can change for you, and what it has already looked up on your behalf. Ora now shows both the installed and the licensed edition of an integration app, answers plan questions about AI agents and Model Context Protocol (MCP) servers for every user, and names the product setting it can change instead of describing the fields behind it. Ora also reads a flow's live configuration to tell you which steps use a script, and Celigo Support tickets arrive with the resource details already filled in. There are no breaking changes this period.
Improvements
- Integration app editions: Previously, Ora reported the integration app edition your account is licensed for. Now, Ora shows the installed edition alongside the licensed edition, tells you when the install is behind its license and which features stay unavailable until the edition is upgraded, and asks you to confirm whether "Request upgrade" was submitted from the integration app's Admin, Subscription page before the question goes to Celigo Support.
- Settings you ask about: Previously, when you asked how to set something up, Ora described the underlying API fields and the edge cases around them. Now, when the whole change is a single setting Ora can make, such as running one flow after another finishes, Ora names the setting the way the product does, "Next integration flow", and offers to make the change for you, staged for your review.
- Script usage across a flow: Previously, when you asked which steps of a flow use a script, Ora read every step's full script and ran a test of the flow to answer. Now, Ora reads each step's live configuration and tells you which steps use that script and in which slot, such as a filter or a preMap, including any step still pointing at an older copy.
- Celigo Support tickets: Previously, when a connection or an on-premise agent was down, Ora drafted a Celigo Support ticket with fields for you to fill in. Now, Ora reads the resource itself, including status, version, last heartbeat, and what changed and when, and writes those details into the ticket along with your own recent edits to the step.
- Plan entitlements for AI agents and MCP servers: Previously, Ora confirmed whether AI agents and MCP servers were included in your plan for administrators, and asked other users to check with an administrator. Now, Ora answers for every user: all Celigo editions include AI agents and MCP servers. Owners and administrators also see the AI credits remaining, the meter that stops agent runs when it reaches zero, and the AI agent actions used.
October 19, 2026: Ora
✨ Ora
Ora can now test an AI agent for you: it sends the agent a message and reports the reply, the tools the agent called, and the AI credits the turn used. Questions about which sources Celigo Sync can read by picking objects now draw on the live source catalog, and an empty object list comes with the reason and the next step. There are no breaking changes this period.
Build and test AI agents
- AI agent testing: Ask Ora to test an AI agent and it sends the agent one message, then reports the reply, the tools the agent called, and the AI credits the turn used. You can test the saved agent, a version waiting in an approval card, or a what-if version from your conversation, and follow-up messages continue the same conversation. Ora asks for your confirmation before each send, because the turn spends your account's AI credits and the agent's tools act for real, and it won't test an agent that has an approval card pending.
Improvements
- Celigo Sync object sources: Previously, Ora answered questions about which sources you can sync by picking objects from a set list of sources. Now, Ora reads the live source catalog, explains what an object is and when Delta is offered, and when the object list comes back empty it tells the causes apart, whether that's a connection pointing at a different API, a connector not yet turned on for object mode, or the list failing to load, and gives you the matching next step.
- Change set merges: Previously, Ora merged a change set when you asked it to. Now, when a change set shows signs of broken linkage, such as the same flow, export, or import removed and added back, Ora describes what it found and waits for your explicit go-ahead before merging.
October 16, 2026: Ora
✨ Ora
This period's changes center on connections, approvals, and troubleshooting. Ora now checks that a connection can do the job before it builds a step, stages a connection swap together with the endpoint updates it requires, and makes sure the change you approve is the change that lands. Troubleshooting is better grounded as well: Ora works from your production flow and the runs you name when you ask about duplicate records, resolves a connection conflict during an integration lifecycle pull, and tells you when a test run replayed saved sample data. There are no breaking changes this period.
Improvements
- Connection fit: Previously, Ora built a step with the connection you named, and the step returned an error on its first run against your live system if that connection served a different purpose. Now, Ora checks that the connection can do the job before it builds, tells you when a different connection is needed, and uses or suggests the one that fits.
- Connection swaps: Previously, pointing a flow's steps at a connection for a different app changed the connection, and you updated each step's endpoint yourself. Now, Ora stages the connection change and the endpoint updates together as one set of approvals, and tells you to hold off on running the flow until all of them land.
- Approval cards: Previously, Ora's quality check reviewed the saved version of a step, so it could stage a second change on top of the one you were about to approve. Now, the check reviews the proposed step, so the change you approve is the change that lands.
- Connections you already have: Previously, when you named an app you have one connection for, Ora asked which account you meant or set up a second connection. Now, Ora uses the connection you already have.
- Integration lifecycle pulls: Previously, when a pull into production hit a connection conflict, Ora described the conflict and pointed you to Celigo Support. Now, Ora resolves the conflict in the product by matching the connection, and when the pull has to run from production, Ora tells you to switch to your production account and picks up from there.
- Duplicate record troubleshooting: Previously, when you asked why a flow wrote the same record twice, Ora reviewed the most recent run and suggested workarounds. Now, Ora reviews the runs from the time you name, works from your production flow rather than a copy of it, points you to the import's concurrency lock and the settings that match incoming data against existing records, and reports whether that lock will engage when it replays a test record.
- Test run results: Previously, a test run reported its results the same way whether it read from your source system or replayed saved sample data. Now, Ora tells you when a test run used saved sample data, so you can see whether the result reflects what is in your source system now.
October 15, 2026: Ora
✨ Ora
This release gives Ora a new way to work with the files in Celigo Storage and speeds up one of its most common diagnostic paths. You can now ask Ora SQL questions about stored CSV, JSON, NDJSON, and Parquet files instead of having it read them as flattened text. Ora also recognizes an expired connection login right away, skipping its usual research pass to give you a direct fix in a fraction of the time.
Query your files in Celigo Storage
- Query files in Celigo Storage: You can now ask Ora a data question about a stored CSV, JSON, NDJSON, or Parquet file, or give it a SELECT statement directly, and Ora queries the file's actual data instead of reading it as flattened text. This works from the File Storage page or from any page when your question is about a stored file's data, and Ora supports totals, groupings, joins, window functions, and common table expressions. Results are capped at 1,000 rows, with a note when more exist, and Ora explains plainly when something won't work — a missing file gets suggested close matches, a folder path needs a trailing slash, wildcards aren't supported, and only read-only SELECT statements are accepted.
Improvements
- Expired connection errors: Previously, when a flow failed because a connection's login or token had expired or been revoked, Ora worked through a list of possible causes and offered a support escalation. Now, Ora confirms the expired login with a live connection test and gives you one direct answer — what happened, and the steps to re-authorize or swap the credential and rerun. Because Ora recognizes this case right away, it skips the heavy research pass, so the answer arrives in a fraction of the usual time. Anything Ora isn't certain is this exact scenario still gets the full diagnostic treatment as before.
October 14, 2026: Ora
✨ Ora
This release extends Ora's approval flow to async helper edits, adds proactive build offers when you ask Ora how to create something, and sharpens how Ora diagnoses connection and record failures. You can now verify a lookup step on demand, ask for time-boxed Support access to your account, and send a single step for real against every connector type. Ora also steers flow building toward native lookup-cache steps instead of custom scripts.
Talk to Ora your way
- Build-it offers: When you ask Ora how to build something — a flow, an API, a Tool, an MCP server, an AI agent, or an export — it now offers to build it for you, staged for your review, or to adapt something you already have.
How Ora keeps changes safe
- Improved: Approval cards: You can now review and approve edits to an existing async helper, including fixing or removing one, through the same approval card used for other changes. Previously, Ora could only tell you to make the change by hand.
Sharper diagnostics, less guessing
- On-demand step verification: You can ask Ora to run a single lookup step for one record, and it shows you exactly what was sent and what came back, instead of leaving you to guess why a lookup isn't matching.
- Improved: Connection diagnosis: When a connection fails at sign-in, Ora now runs a full diagnosis of the connection's authentication setup and which OAuth app it uses, and asks what a sign-in error page said instead of guessing.
- Improved: Error diagnosis: When Ora already knows why records are failing, it now explains why only some records are affected as part of that answer, instead of adding an unrelated guess alongside the real cause.
- Improved: Testing a step for real: Sending a single step for real now works for every connector type, using the same flow and integration settings a real run would use.
Faster path to Celigo Support
- Time-boxed Support access: When you ask Ora for a Support ticket, it still drafts one ready to paste, and now also offers to open time-boxed Support access to your account so Celigo can keep working the problem directly.
Smarter flow building
- Improved: Flow building guidance: When you ask Ora to track state between runs, deduplicate records, or look up reference data from a lookup cache, it now builds that logic as flow steps — a lookup, a router, an import — instead of recommending a script.
October 12, 2026: Ora
✨ Ora
This period expands what Ora can do with your files and data, adds new Mapper 2.0 editing options, and sharpens how Ora diagnoses and reports on errors. Ora now manages Celigo Storage files end to end, finds file definitions through the steps that use them, and pulls up flow run history for any date you name. On the diagnosis and safety side, Ora gives more honest explanations when it isn't certain of a cause, recognizes when the platform has actually refused a staged change, and hands Celigo staff its findings directly instead of routing them to Support.
Finding what you need, faster
- Move and manage Celigo Storage files: You can now ask Ora to move files and folders in Celigo Storage, check storage usage for the account or a specific environment, get a folder's zip download link, and scope API tokens to specific storage paths. Previously, Ora could only create, update, read, and list files, and treated Celigo Storage as admin-only.
- Open file definitions from the step that uses them: File definitions don't have a page of their own, so Ora now opens the export or import step that uses the one you ask about. When multiple steps or definitions share a name, Ora asks which one you mean instead of guessing.
- Pull up run history for any date: Ask Ora for a flow's run logs from a specific date, and it lists that day's runs with status, record counts, and whether logs were captured, then opens the one you want. Previously, Ora could only reach the most recent run.
Map and transform data your way
- New Mapper 2.0 options: Ora can now set a block of mapping rows to inactive or make a record fail when a source field is empty, using the "Set inactive" and "Cause record to fail" options the platform added in the 2026.10.1 Mapper 2.0 and Transformations 2.0 update.
Diagnose and fix errors
- Improved: Stuck-flow diagnosis: Asking why a flow is slow, stuck, or queued now gets you a real diagnosis, including queue depth on the shared connection, who's ahead of you, and per-job timing, instead of a generic run-time summary and a support-ticket template.
- Improved: Error diagnosis honesty: Ora no longer presents a guess as a confirmed cause. When a step has never had a successful run, Ora says plainly there's no baseline instead of blaming a recent edit. When a record's rejection reason isn't directly visible, Ora compares it against a record that succeeded before naming a cause, and it only names a specific Integration App mapping row as the fix when evidence actually ties it to the failure.
- Improved: Direct answers for Celigo staff: When the person chatting with Ora is Celigo staff rather than a customer, Ora now hands over the evidence and findings it already gathered directly, instead of directing them to file a Support ticket.
How Ora keeps changes safe
- Improved: Approval cards: When the platform actually refuses a staged change you accepted, Ora now recognizes the refusal instead of assuming your click didn't register. It explains what was refused and what to do next, rather than suggesting you retry.
October 9, 2026: Ora
✨ Ora
This period's Ora changelog covers two improvements to error diagnosis and two to approval cards; no new capabilities shipped in this window. Ora's error analysis now checks whether a documented cause actually applies before confirming it, and leads with the business identifier you recognize instead of an internal record ID. Approval cards now warn you before a resolve hides unprocessed records, and a scoped SQL or request edit changes only what you asked for instead of rewriting the whole statement.
Diagnose and fix errors
- Improved: Error cause confirmation: When Celigo's documentation ties an error message to a cause that only applies under a specific condition, Ora now checks that condition before calling it the confirmed cause, and says plainly when it can't confirm one. Previously, a generic NetSuite "please enter a value for Amount" error could come back as a confirmed item-group problem on an item that wasn't one.
- Improved: Record identifiers in error diagnosis: Ora now leads with the business identifier you recognize, such as the order, fulfillment, or document number, instead of an internal record ID, looking it up in the source system when needed. If you ask about a different record than the one the error actually belongs to, Ora says so up front instead of silently investigating the wrong one.
- Improved: Flow rerun follow-through: When a rerun you asked for to test a diagnosis fails, Ora now pulls up and reads the new errors itself before reporting back, instead of citing an error count and stopping or asking you to find an error ID.
How Ora keeps changes safe
- Improved: Approval cards for resolving errors: Before resolving flow errors, Ora now checks whether a later run actually reprocessed those records. If it didn't, Ora says so directly on the approval card instead of letting a resolve quietly hide unprocessed records, and leaves the decision to you.
- Improved: Scoped edits in approval cards: When you ask for a small, scoped change to an existing import's SQL query, request URL, or body template, Ora now edits only what you asked for instead of regenerating the whole statement. The approval card also describes the change by its actual before-and-after difference rather than by what Ora intended.
October 8, 2026: Ora
✨ Ora
How Ora keeps changes safe
- Account-wide SSO as an approval card: You can now turn on Require SSO for all users for your whole account directly through Ora, staged as an approval card like any other change. Ora checks that SSO is already enabled for the account before staging the change and confirms that only the account owner can update the account owner's SSO requirement. On the Users page, Ora no longer offers the per-user SSO toggle once the account already requires SSO for everyone, since the account-wide rule already covers that user.
- Improved: Platform-managed settings: Some settings only look editable. For example, on a Snowflake bulk-load import, the platform derives the CSV options, so a change to them is silently discarded. Ora used to stage that change anyway and report it as applied. Now Ora recognizes when a setting is platform-managed, explains why upfront, and offers a route that actually works, such as a hook, a mapping change, or a fix to the source data.
Diagnose and fix errors
- Improved: Integration Lifecycle Management errors: When you ask Ora for version history, a snapshot, or a pull on an Integration App, it now gives a clear explanation, drawn from the platform's own error, that lifecycle management isn't available for Integration Apps, since they're installed per environment. Previously this request returned a confusing "malformed request" error.
- Improved: skipped-records troubleshooting: When a flow run shows records being skipped, Ora now stages a debug-logging approval card directly in its diagnosis instead of only suggesting one, so the next run captures the answer. Before escalating to Celigo Support, Ora checks the record it's already holding against the likely cause and includes that finding in the support ticket, so Support starts from evidence rather than from zero.
Build smarter with Tools, APIs, and agents
- Schema-aware editing for Tools, AI agents, and guardrails: Ora now keeps the schema editor you chose, Manual or JSON, when it edits a Tool's input or output schema, an AI agent's structured output, or a guardrail. In the Manual editor, Ora writes within that editor's vocabulary, including required fields, enums, regex patterns, numeric ranges, and length or array-size limits, so nothing the editor can't display gets dropped on the next save. When a change needs a rule only the JSON editor supports, such as format validation, $ref, oneOf, or const, Ora asks before switching the resource to the JSON editor rather than switching on its own. New Tools, AI agent structured outputs, and guardrail schemas now default to the JSON editor so advanced rules are preserved from the start.
- API groups and one-step connection swaps in API builder: You can now file an API into an API group when you create, clone, or move it, and Ora can create, rename, delete, or reassign API groups the same way it already handles flow groups. Replacing a connection on an API or a Tool is now a single step instead of a step-by-step process.
- Lookups that use your input: Ora can now build Salesforce, NetSuite, and database lookups whose query depends on an incoming value, such as finding the record whose name matches what someone typed. Previously, these lookups failed to build for any system other than HTTP, because Ora's test step couldn't bind the input value, and the builder had to finish the lookup by hand. Ora now previews the lookup the way the flow builder does, with the real record bound, and verifies it live before saving, in Tools, APIs, and flows alike.
- Improved: Testing steps with real data: Sending a single step for a live test now works for Salesforce, NetSuite, database, and file steps, not just HTTP. Previously, only HTTP steps could be sent for a live test; for every other step type, Ora suggested adding a mock input record instead.
Expanded platform coverage
- Scoped Celigo sync runs: You can now ask Ora to run or re-sync only the tables you name in a Celigo Sync, for example "re-sync just the Account and Contact tables" or "re-run only what failed last night." The other tables keep their existing data, checkpoint, and last-run status. Ora won't enable a table that's disabled on the sync without asking first, and it knows the 500-dataset cap on a single run.
Getting finished work to production
- Improved: Promoting finished flows: Ora now gives a direct answer to "how do I get one finished flow to production without the half-done ones coming along?" It leads with what already works today: previewing the pull before merging, snapshotting first so you can revert, and keeping unfinished work on a disabled copy of the flow. Developers who ask in CI/CD or version-control terms get a pointer to the Celigo CLI's Git workflow. When Ora does file a feature request, it now also says what you can do in the meantime, and lifecycle questions asked from a flow page reach the right guidance.
October 5, 2026: Ora
🚀 Ora
This period, Ora adds a safer way to connect to AWS, full visibility into Tool run history, and several improvements to how it diagnoses and resolves flow errors. Ora can now authenticate Amazon S3, Amazon Redshift, and AWS Service, Textract, and Bedrock connections with IAM roles instead of access keys, and it can read a Tool's complete run history the way the Logs tab does, plus answer analytics questions the UI can't. Error diagnosis gets faster and more specific: Ora can now propose a fix for backed-up NetSuite queues, pinpoint when and why a flow started failing, and recognize retired flows. Asking Ora for a human now gets you a paste-ready support ticket with the real error details instead of a blank form.
Connect to AWS without storing keys
- IAM role-based AWS connections: You can now connect Amazon S3, Amazon Redshift, and AWS Service, Textract, and Bedrock connections using an IAM role instead of storing access keys. Ask Ora to create the AWS IAM iClient with your role ARN, and it generates the external ID, fills in the trust-policy JSON for Celigo's AWS account, and binds the right iClient to your connection while enforcing the correct role-name prefix for that service family.
- Switch between access keys and IAM roles: Ask Ora to switch an existing S3, Redshift, or AWS Service connection between access-key mode and IAM-role mode, and it stages the change as an approval card.
- Guided AWS setup and troubleshooting: Ora walks you through the AWS console steps, including the trusted account, the external ID, and the permission policy, and explains what a failed connection ping means, whether that's a missing external-ID condition, a mismatched external ID, an untrusted principal, or missing permissions.
See exactly what your Tools are doing
- Full Tool run history: Ora can now read a Tool's real run history the way the Logs tab shows it, including every recorded run, a step-by-step trace of a single run, and the payload at any stage.
- Run analytics the Logs tab can't answer: Ask which agents, guardrails, or MCP servers call a Tool most, the busiest hour or day in a window, how many runs failed, or latency at the median, the 95th percentile, and the worst case. You can also filter to only the failed runs, runs over a certain duration, or the run tied to a specific order number or SKU.
- Direct links to the Logs tab: Ora now deep-links straight into a Tool's Logs tab and trace view instead of describing where to find them.
Errors get fixed, not just explained
- One-click fix for backed-up NetSuite queues: When a flow is stuck behind a NetSuite connection with a low concurrency setting, Ora now proposes raising it as a ready-to-approve action, and checks the combined concurrency across every connection on that NetSuite account first, so one change can't overload the shared limit.
- Pinpointing when and why errors started: Ora's diagnosis can now date exactly when a flow's errors began and tie that to a neighboring flow's traffic spike, and it recognizes when a flow was quietly switched to route through a different step, naming the setting that changed and what mapping the new step is missing.
- Awareness of retired flows: When an error is on a flow or Integration App step that Celigo has already retired, Ora now identifies that and points you to the current replacement flow.
- Smarter replay suggestions: If a record's original error has already been resolved, Ora now offers that step's other open errors to replay instead of stopping.
Getting a person involved, faster
- Paste-ready support tickets: When you ask Ora for human help while looking at a failing flow step, it reads the error on your screen and drafts a paste-ready support ticket with the real error details, while still offering to keep troubleshooting with you.
- Help when Ora doesn't know the answer yet: If Ora doesn't know what's wrong, it asks what you need and offers to try first, alongside the option to escalate.
- Clarifying an overloaded term: Asking for an "agent," a term that means different things at Celigo, now gets a clarifying question grounded in what's on your screen instead of a guess.
September 16, 2026: Ora
✨ Ora
This week, Ora gained ground in trading partner connections, account-wide visibility, and AI agent building. It can now set up an EDI connection directly from Celigo's published connector templates, report flow trends across an entire account instead of one integration at a time, and build a working AI agent and the flow that runs it from a single plain-language request. MCP server management also picked up two new hands-off actions for connections and end users.
Ora now runs a real Playground agent that runs templates, scripts, and parsers against your pasted data instead of just describing it. Ora also gets more self-sufficient with connections: it can swap a connection across an entire flow, clear the way for a stuck deregistration, and act on plain statements like "the timeout should be 30 seconds" instead of just describing the current setting. Separately, Ora's scripting knowledge now covers the platform's own lookup-cache and export/import APIs; it can tell you exactly where flow notes and TODOs belong, and every new chat now gets a meaningful title automatically.
Connect to EDI trading partners
Set up EDI connections from published connector templates: Ask Ora to connect to a trading partner such as Target over AS2, and it walks the same Protocol → Region → Business model path as the connection form's Trading Partners picker, filling in the partner's template values and asking you only for the details only you can supply, such as your SFTP host or AS2 identifier. If Celigo hasn't published a connector for that partner, Ora points you to the request process instead of building a placeholder connection.
Diagnose and fix errors
Account-wide flow trend reporting: Ask for flow error trends, success rates, or processing time across your whole account, and Ora returns a real day-by-day series for every flow instead of a rough snapshot. On large accounts, it asks you to narrow the request rather than stalling.
Visibility into legacy two-step flows: Ora can now see the steps inside legacy two-step flows, including most 1.0 Integration App flows and Data Loader flows. These used to look empty to Ora, so step-level fixes such as mapping edits now work on them too.
Live fact-checking in connected apps: When the evidence doesn't settle what caused an error, Ora reads the live record in the connected external system, such as NetSuite, to confirm what's actually there instead of leaving that check to you.
MCP servers and AI agents
Per-server connection overrides: Point a published Tool at a different connection for a specific MCP server — for example, use a sandbox connection on your QA server — directly from chat.
Sign-in provider visibility: Ask Ora to show your account's external sign-in providers, such as Okta or Auth0.
Suspend and re-enable MCP end users from chat: Tell Ora to disable or re-enable an end user's MCP access, or remove a person's direct MCP server grant, and it stages the change as an approval card without a trip to the End users page.
Build AI agents from real integration patterns: Describe what you want an agent to do — read a mailbox and its attachments, classify documents from storage, answer questions in a Slack thread, or wait for your approval before acting — and Ora builds it using the same patterns behind the Marketplace's AI agent templates.
Agent requests that come with their own flow: When a request needs a flow around the agent, such as "an agent that watches X and suggests Y," Ora asks where the input comes from and where results should go, builds the flow with the agent inside, and hands you the exact steps to take it live.
Talk to Ora your way
Remembering your preferred level of detail: Ora can now offer to remember how much explanation you like and carry that preference into future chats.
A live sandbox for testing expressions
Playground agent: On the Playground page, Ora now renders, diagnoses, and writes Handlebars and SQL templates, filters, transform rules, and scripts, and parses CSV and XML, against the actual data you paste in, run through the same processors the editors use. Paste an expression and sample data from any page, and Ora routes it to an agent that can run it for real instead of just describing what it should do. Nothing on the Playground is saved; when you want the result applied to a real export or import, Ora hands it off and stages the change for your approval.
Connections that manage themselves
Connection swapping: Ask Ora to replace one connection with another, and it performs the swap itself across an entire flow, including API and Tool steps, staged for your approval, instead of walking you through the menus by hand.
Clearing the way to deregister a connection: When a connection won't deregister, Ora now shows exactly what's still using it, such as flows, API or Tool steps, aliases, or syncs, proposes moving everything to a same-type replacement, and deregisters the connection once you approve.
Acting on "should be" statements: Tell Ora "the timeout should be 30 seconds" on a connection, and it now treats that as a change to make, staged for approval like any other edit, instead of just describing the connection's current setting back to you.
Per-instance webhook URLs: For a multi-instance flow, Ora can now generate a separate, working webhook URL for a single instance by cloning the template's listener, so a webhook hit reaches only that instance.
Scripts and knowledge that go deeper
Scripting against the platform's own APIs: Ora now knows Celigo's built-in script API. Ask it to read or update a lookup cache, keep state across script runs, or run an export or import from inside a script hook, and it writes working code instead of saying it's impossible.
Guidance on where notes and planned work belong: Ask Ora whether you can add a comment or TODO placeholder to your flow, and it points you to the right spot, such as a flow or step description or the integration readme, and offers to write the note for you.
Integration App edition awareness: Ora can now see the installed edition of an Integration App against your licensed edition, so a question like "why is this setting missing?" gets a direct answer, such as which edition includes it and how to upgrade, instead of a hedge.
Keep your chat history organized
Automatic chat titles: Every new Ora chat now gets a short, meaningful title generated automatically from the first message, including chats that start with just a file upload. A vague opener, such as a greeting or a lone file, gets its title upgraded after Ora's first reply so your chat history stays easy to scan. Renames you make by hand always stick.
September 4, 2026: Ora
✨ Ora
This week, Ora expands what admins can do with MCP end users, sees deeper into API and Tool run history, and works more fluidly across multi-instance flows and multi-environment accounts. It also speaks the platform's newest Handlebars additions and recognizes three new file providers, with clearer file-metadata handling across the board.
Know and manage who's using your MCP servers
- See who's using your MCP servers: Ask "who are my end users," "did Jane accept her invite," or "who's in the Finance group," and Ora answers from live rosters and group membership across the account.
- Understand exactly what access someone has: Ask what a specific end user or MCP server grants, and Ora shows which direct, group, or role grant delivers each permission, and flags access that's granted but unusable.
- Find and trace end users from any page: Search the account for an end user or group by name or email and see their groups, servers, and invite status. Ask what would be affected if you deleted an MCP server, and Ora lists every end user and group that would lose access. This data stays visible to admins only.
- Invite, revoke, and manage end users and groups from chat: Ask Ora to invite or revoke an end user, or create, update, and manage end-user groups and membership. Every change stages as an approval card first, and the audit log attributes it to Ora.
- Grant MCP server access by group: Ask Ora to give a group access to an MCP server, and it stages the grant with a before-and-after summary.
Review your history
- Ask about API and Tool run history: Ask Ora to show an API's failed requests from last week, its busiest hours, or when a specific record came through. Ora walks a single request step by step with the exact payloads, and can turn log capture on or off or purge logs on request. The same capability extends to Tools, and activates automatically once the platform's Tool invocation history feature is live.
- See exactly what Ora has changed: Ask "what has Ora changed recently," and Ora now queries the audit log using the platform's dedicated attribution source, so its own changes are correctly identified.
Work across flows and environments
- Work with multi-instance flows: Ask about a multi-instance (template) flow, and Ora lists every instance and which are enabled. Ask Ora to run every instance of a flow, and it starts each enabled instance, skips paused ones and the template itself, and reports what actually ran.
- Work across production and sandbox: Ora now knows that environments are separate accounts under the hood. Point it at a resource in another environment, and it explains the boundary instead of guessing wrong. Ask it to copy your sandbox mappings to production, and Ora writes a ready-to-paste handoff message for the Ora session in that environment, which does the work and replies with an answer to paste back.
- Trace exactly where a flow's data stops: Ask why data isn't reaching a step, and Ora runs the flow in test mode and narrates the record's journey, including which branch it took, which filter dropped it, and where it stalled, even on flows that have never run. Ora can show the exact request a step would send without leaving the building, or, only when you say so, actually send it and show the real response.
Write smarter templates and imports
- Author date math with readable units: Ask Ora to add three days to a date, and it produces {{dateAdd date 3 "d"}} with readable interval units instead of raw milliseconds.
- Read a lookup cache directly in a template: Templates can now pull a value straight from a lookup cache with {{getLookupCacheData}}, and the template editor validates the result against your real integration and flow context.
- Fan out AI agent and guardrail imports: Ora now understands one-to-many fan-out for AI agent and guardrail imports, where a single incoming record with an array becomes one agent invocation per child element.
Handle more files, more precisely
- Move files from more providers: Ora now treats Google Cloud Storage, ADLS Gen2, and Celigo APIs as full file providers. Ask it to move files from a GCS bucket, and it builds the correct folder-transfer flow, including GCS's own bucket-and-key-prefix addressing.
- Stamp file provenance on more exports: File-reading exports and lookups across FTP, S3, AS2, local file system, NetSuite file cabinet, and cloud-storage folders can now stamp each record with the source file's name, size, and last-modified date.
- Get a clear answer when a stamp isn't possible: If you ask for a file-provenance stamp on a step that doesn't read files, Ora explains why that can't work and offers a record-field alternative instead of quietly saving something broken.
- Retarget file exports by folder: Ora can now point a file-provider export at a new folder ID directly, updating the real directory binding rather than the display path alone.
September 2, 2026: Ora
✨ Celigo Ora: Beta through GA
From the March 2026 beta to general availability, new Celigo Ora capabilities brought major enhancements to the integrator.io platform. You can now leverage flexible interaction options, deeper account-specific context, dynamic error diagnosis, and tighter change guardrails. Additionally, these features deliver expanded search, approval, and audit capabilities across the entire environment. The following sections outline what shipped by capability area.
Talk to Ora your way
- Run multiple conversations at once: Open Ora in several browser tabs, or start several conversations in one tab, and keep separate pieces of work moving in parallel.
- Dictate instead of typing: Speak your prompt, and Ora transcribes it, including long dictations, in your language.
- Attach files and screenshots: Drop an error screenshot, a CSV, or an API spec into the chat, and have Ora work from it. You can add references to Celigo Storage files in your chats.
- Ora inside the mapping and expression editors: Mapping and expression editors now have Ora built in, replacing the legacy AI helpers. Ask "what does this field do?" for an explanation, or ask for a change and review it as a diff before it's applied.
What Ora knows about your account
- Teach Ora once, and it remembers: Say "remember this," and Ora saves it either in the integration's readme for team knowledge or as a personal rule that follows you across every account you work in. Every saved instruction is a visible, editable file, not a hidden memory store.
- Integration App expertise: For managed apps such as Shopify–NetSuite and Amazon–NetSuite, Ora knows what each flow does, which setting governs each behavior, and the documented fixes, grounded in official Celigo docs and your account's configuration.
- Custom integration awareness: Ora builds a working profile of each custom integration, including what it does, which pieces are risky to change, and its normal volumes, and uses that profile to answer questions, diagnose errors, and search your account.
- Flexible account search: Search by name, rough description, configuration (for example, "all disabled flows"), relationship ("which flows use this connection"), or count ("how many flows per integration"), and get complete, exact answers instead of a top-10 sample.
- Contextual awareness: Ora knows what you're working on and recommends prompts to help you build and troubleshoot quickly.
Diagnose and fix errors
- Evidence-based diagnosis: Ora pulls the actual failed record and request/response data, checks whether a recent configuration edit lines up with when errors started, and states what's confirmed versus what's a hypothesis, plus the one check that would settle it. Known Integration App errors surface their documented fixes.
- Live fact-checking in connected apps: Ora can read the live record in NetSuite, Salesforce, or your database (read-only) through connections you already have to confirm details such as whether a record still exists or is still open.
- Bulk error actions by record content: Describe a group of errors by what's inside the failed payload, such as orders with no line items or records where the country isn't US, preview the count, and act on the whole set.
- Plain-language retry fixes: Describe a correction, and Ora applies it across one error or thousands, using the platform's own processor so records aren't reshaped or dropped. Every fix stages for your approval.
- Record tracing and replay: Trace a record through a run step by step, or replay a failed record through a step's filters and mappings without sending anything to the destination. Ora can also explain why a record was ignored, check whether a run is stuck, read connection debug logs, and inspect lookup cache contents, all from chat.
- Anomaly detection over any time window: Ask about anomalies over any date range, for example "any anomalies in my flow executions in the last 15 days?", and Ora checks every day in that window, catching error spikes, volume drops, and flows that quietly stopped running on the day it happened. Previously, Ora could only assess the last 24 hours.Builders running high-volume NetSuite integrations or data warehousing workflows, and developers who prefer REST over SOAP or need direct access to custom NetSuite record types.
How Ora keeps changes safe
- Self-testing before saving: Every mapping, template, query, filter, and script Ora writes runs through Celigo's real processors against your sample data, is judged against what you asked for, and is corrected until it's right. If something can't work, Ora says so instead of saving a broken artifact.
- Staged approvals with verification: Every change stages as an approval card, validated against the platform before you accept it, individually or all at once. Ora tracks what you approved, resends any card that didn't land, verifies after acceptance that the change persisted, and attributes every action in your audit log.
- Builds that finish the job: Flow, API, and Tool builds are grounded in real sample data at every step, verified end to end, and auto-repaired before delivery. You can keep editing a flow while Ora builds it, since it merges your changes rather than overwriting them. Quick edits such as renames, schedules, and enable/disable now stage in seconds.
Find and install from the Marketplace
- Search by meaning and template content: Describe your problem in your own words to find the right Marketplace listing, search inside every template for the specific flow or agent tool you need, and check which candidates actually fit your account before you install.
- Marketplace browsing and install visibility: Browse and install AI Agent listings directly from chat, check what's new in the Marketplace, and see upfront during a wizard install which external steps are already complete in your account.
Expanded platform coverage
- Real-time database listeners: Build change-data-capture exports from plain language for MongoDB change streams, SQL Server CDC, and PostgreSQL logical replication.
- MCP servers and AI agents: Build MCP servers complete with tools and prompts, and publish Celigo Storage documents as read-only MCP resources. You can also create Claude-powered AI agents with your own Anthropic key, subscribe agents to governed MCP resources, and diagnose errors on AI agent flow steps.
- Integration lifecycle management for APIs and Tools: Snapshot, pull, and revert now cover APIs and Tools in addition to flows, with previews and field-level diffs before anything merges, plus lifecycle-linked clones that stay connected to their source.
- Deeper configuration coverage: Author custom settings forms with live dynamic dropdowns pulled from NetSuite, Salesforce, and your saved searches; manage Integration App settings (1.0 and 2.0); use Handlebars on object and array fields in Mapper 2.0 and directly in filter and branch rules; add JavaScript hooks, filters, transforms, and branching on flows, APIs, and Tools; and create Personal Access Tokens directly from chat.