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.