Articles in this section

Ora changelog

Kathyana Queeman
Updated

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

This period's Ora updates expand what you can stage as an approval card, improve how Ora diagnoses and escalates errors, and add new ways to build in tools, API builder, and syncs. Account-wide SSO joins the list of settings you can change through Ora as a staged approval, and clearer error messages cut down the steps needed when a lifecycle pull or a skipped record needs attention. On the building side, Ora now respects your schema editor choice, groups APIs, and can run only the Celigo Sync tables you name. Ora can also build lookups that depend on an incoming value across Salesforce, NetSuite, and databases, send more step types for a live test before you save, recognize settings the platform controls instead of reporting them as changed, and give a direct, in-product answer for moving one finished flow to production without the unfinished ones.

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.

Celigo Ora overview

Error management with Celigo Ora