Flow (Automation)

Build automations the easy way — describe what you want and AI builds it, or drag steps together. Triggers, AI, HTTP, email and more. Living document — we expand it as the product grows.

1. What is Flow?

Flow is Genexti's automation builder (like n8n/Zapier, but easier and AI-first). A workflow is a series of steps (nodes) that run in order: a trigger starts it, then actions do the work (call an API, ask AI, send an email, transform data…).

Who it's for: anyone who wants to automate tasks — no coding needed.

2. Getting started

1. Go to /flow (the Flow dashboard).
2. Two ways to start:
   • ✨ Build with AI — describe it in plain English (recommended for beginners).
   • Blank — start with an empty canvas and add steps yourself.

3. ✨ Build with AI (the easiest way)

1. Click ✨ Build with AI.
2. Type what you want — or tap the 🎤 mic and just say it (speak in almost any language; your words are transcribed automatically). E.g. "Every morning, write a motivational quote and email it to me."
3. Click ✨ Build it.
4. Flow creates the whole workflow (steps + connections + settings) and opens it. Example result: Daily Trigger → Generate Quote (AI) → Send Email.
5. Review the steps, fill anything personal (like the "To" email), then Run.

More examples to try: "Every morning email me Karachi's weather" · "Email me today's tech news" · "When a webhook is called, summarize the data with AI and email it to me."

Live / current info (weather, news, prices, sports, research): the AI builder automatically adds a fetch step (Web Search or an API call) before the AI, so answers use real data — it never makes up facts. If something needs a paid data feed (e.g. an exact live stock quote), it adds a fetch step named "…(set your API key)" for you to plug your key into.

3b. 📚 Start from a template

• The Workflows home shows your own workflows first, with a short "Start from a template" teaser and a Browse all → link.
• The full gallery lives in the Templates tab (left sidebar) — 100+ one-click starters across 17 categories, with a search box, category filters, and a "by app" filter (plus an AI-build box: describe it → AI builds it), grouped by category (Personal, Business, CRM & Sales, E-commerce, Forms, Content, Analytics, DevOps, Support, Team, Finance). Examples: Daily News Digest, Contact Form → AI → Email, New Lead → HubSpot, Form → Notion, Typeform → AI Digest, New Order → Slack, AI Blog → WordPress, Signup → PostHog + Welcome, Website Uptime Monitor → Pushover, Support → Zendesk, Daily Standup → Mattermost. Click one and it creates a fully built, ready-to-run workflow you can tweak.

📚 Big multi-app templates (the ones that branch)

Most starters are a short straight line. These thirty-five are bigger: an AI reads the incoming event, decides what kind of thing it is, and each kind goes somewhere different — the shape real work actually has. Open one to see how branching, structured AI output and several connected apps fit together.

A note if you edit these. A step only ever receives the previous step's output. So {{body.email}} works right after a Webhook, but once an AI step has run, the payload is the AI's result and {{body.email}} there quietly resolves to nothing — no error, just an empty value. That's why these templates carry anything later steps need through the AI's structured output ({{data.…}}), and why steps that each need the AI's result branch off it side by side instead of running one after another. Use the ⑂ Schema tab on a step's output to see exactly which field names are available to the step after it.

4. The canvas (building manually)

• Left palette: Triggers (Manual, Schedule, Webhook) and Actions (Genexti AI, Web Search, Code, Send Email, Telegram, Slack, Discord, Filter/IF, HTTP Request).
• Add a first step: click a Trigger in the palette.
• Add the next step: click the purple "+" under a node → pick the next step → it's added and auto-connected (the easy way — no manual wiring).
• Move nodes: drag them around.
• Configure a node: click it → set its fields in the right panel.
• (Advanced) manual connect: click a node's right dot, then click the target node.

5. Triggers (what starts a workflow)

5b. 📝 The Form trigger (a public form, no website needed)

You don't need a website, an embed code, or a form service. Add a Form trigger, write your questions, activate the workflow, and share the link.

Building it

• Form title and an optional short description shown above the questions.
• Questions — add as many as you like. Each has an answer type: Text, Long text, Email, Number, Date, Dropdown (you supply the choices) or Checkbox — and can be marked required.
• Button text and the message shown after submitting.

Sharing it — the node shows a Form link with a copy button and an ↗ to open it. The page is mobile-friendly, follows light/dark automatically, and needs no account from whoever fills it in.

Using the answers — each question becomes a field named after its label: "Your email" → {{your_email}}, "Company size" → {{company_size}}. The node lists the exact names for you. They're also available as {{body.your_email}} if you prefer. A checkbox arrives as true / false.

A natural pairing with §6c: Form → AI drafts a reply → Wait for a Person → If approved → Send it.

Good to know

• The workflow must be Active — an inactive one shows "not accepting responses" instead.
• Required questions are re-checked on the server, not just in the browser, and what they already typed is kept when an error is shown.
• Submissions count towards your plan's monthly runs, the same as webhook calls.

5c. 💬 The Chat trigger (talk to your AI Agent)

A shareable chat page where people type a message and your workflow answers. This is the front door for the AI Agent (§6a) — together they make a real assistant you can put in front of customers.

Building it

• Chat title, an optional first message shown before they type, and the input placeholder.
• Reply comes from — The last step automatically works for the AI Agent and Genexti AI (it picks up output / text / answer). Choose A field I name if your last step returns something else.

The 60-second assistant

1. Chat trigger → AI Agent
2. Set the agent's User message to {{message}}
3. Turn its Memory on, and put {{sessionId}} in "Separate conversations by"
4. Activate, copy the chat link, share it

Step 3 is the one people miss: without it every visitor shares one conversation and the agent gets confused about who it's talking to. {{sessionId}} is unique per visitor, so each person gets their own memory.

What each message gives you — {{message}} (what they typed) and {{sessionId}} (that visitor's id). Both also available as {{body.message}} / {{body.sessionId}}.

Good to know

• The workflow must be Active, and messages count towards your plan's monthly runs.
• The page is mobile-friendly, follows light/dark, and loads nothing from the internet — so it works on locked-down networks.
• If your workflow errors, the visitor sees a polite "something went wrong" — never your internal error. You see the real reason in the run history.
• Give the agent tools (Web Search, HTTP Request, a sub-workflow) and the chat can actually do things, not just talk.

6. Action & logic nodes

6b. Data & AI power nodes

These make workflows genuinely capable. The list nodes work on an incoming list (from RSS Read, Get Rows, a Loop, etc.):

Tip: to run one node then another (e.g. Limit then Sort), connect them in a single line A → B → C. Each node reads from the node wired into it.

Text & data utilities — self-contained helpers (no account/key needed) for shaping data mid-workflow:

6c. App integrations (80+ apps, real logos)

Connect an app once under Connections (your key is encrypted), then drop its node into any workflow. In the editor palette they're grouped by category — each node does one clear action:

• AI & LLMs (generate text with your own key) — OpenAI, Claude, Google Gemini, Groq (free tier), Mistral, Perplexity (web-grounded), DeepSeek, Grok (xAI), OpenRouter (any model), Together AI, Fireworks AI, Cohere, ElevenLabs (text-to-speech — returns MP3 audio). (Plus Genexti AI — no key needed.)
• Messaging & Communication — Slack (full: post/update/delete messages, channel history, list/create channels, set topic, list users, user info, reactions — via a connection; or a quick webhook post) & Discord (full: send/edit/delete messages, read messages, reactions, get/create channels — via a bot connection; or a quick webhook post) & Microsoft Teams (webhook URL, no login), Zoom & Google Meet (create a meeting + join link), Telegram (bot — full: message/photo/document/poll/location, edit, delete, pin/unpin, answer callback, chat info), WhatsApp (Cloud API — send text/template/media/location + mark as read), Twilio (SMS), LINE, Mattermost (post to a channel), Pushover & OneSignal (push notifications), Intercom (create contact), Zendesk & Freshdesk (create ticket).
• Email — send via Gmail, SendGrid, Mailgun, Brevo, Mailjet (plus the built-in Send Email).
• Analytics — PostHog (capture event), Segment (track event), Mixpanel (track event) — pipe workflow data into your product analytics.
• IT Ops & Monitoring — ServiceNow (create record), PagerDuty (trigger an incident), Datadog (post an event), Sentry (capture a message).
• Marketing — grow your list: Mailchimp, Klaviyo, Kit (ConvertKit), ActiveCampaign, GetResponse (add contact to a list), MailerLite (add subscriber to a group), Customer.io (identify person / track event), Iterable (track event / update user).
• Utility — OpenWeather (current weather for any city or coordinates) and Google Maps (geocode an address to lat/lng, or reverse). Handy building blocks: weather-triggered alerts, enrich a lead's address with coordinates, etc.
• Security & Identity — Okta (create / find / list / deactivate users — enterprise provisioning) and Splunk (send events to your Splunk index via the HTTP Event Collector). Example: New signup → Okta (Create user) → Splunk (log the event).
• More business apps — Gorgias (open a support ticket), BigCommerce (create/get/list catalog products), Razorpay (create a payment link — popular in India/Asia), Amplitude (track a product-analytics event), Opsgenie (raise an on-call alert), Close (create/search CRM leads).
• Productivity — Notion (add page), Airtable (add record), Google Sheets (append, append-or-update/upsert, get rows, lookup, update cells, clear, create tab, delete rows), Google Calendar (create/update/get/list/delete events + attendees/all-day, quick-add, list calendars, check availability), Google Docs (create a document, read its text, append or insert text, find-and-replace, share), Google Tasks (create/list/get/update/complete/delete tasks, and manage task lists), ClickUp / Trello / Todoist / Asana / Linear / monday.com (create task/card/item/issue), Coda (insert row), Webflow (CMS item), WordPress (create post), Ghost (create post — draft or published).
• CRM — Zoho CRM, Salesforce, HubSpot and Pipedrive are full multi-operation nodes: pick a Resource (Lead, Contact, Account, Deal, Company, Ticket, Organization, or a custom object) and an Operation (Create, Update, Get, Get many, Delete, Search/upsert), and the fields adapt automatically.

🧩 Rich multi-operation nodes: many of the most-used apps are now full Resource × Operation nodes (one node does create / update / get / list / delete / search, with fields that change per operation) — currently OpenAI (Text: message/moderation · Image: generate/analyze · Audio: speech/transcribe · Embeddings), Claude (Text: message · Image: analyze · Document: analyze PDF), Zoho, Salesforce, HubSpot, Pipedrive, Airtable, Notion, Google Sheets, Stripe, Trello, Asana, monday.com, ClickUp, Shopify, Mailchimp, Todoist, GitHub. More join this set over time; anything else is covered by the universal HTTP Request node.

• Microsoft 365 — Outlook (send email from a mailbox), OneDrive (upload a file), Excel (add a row to a table), SharePoint (upload a file to a site) — all via Microsoft Graph using your own Azure app. One app registration (with the right Graph permissions) powers all of them.
• Storage — Google Drive (upload, download, list, search, share, copy, move, rename, create folders, and delete to trash), Dropbox and Box (upload a file to a path/folder). Both are now one-click Connect: paste your own app's key + secret once, authorize in a popup, and the token stays fresh automatically.
• Developer & Deploy — GitHub, GitLab, Jira (create issue), Bitbucket (create issue), Cloudflare (purge cache), Vercel (trigger deploy), Netlify (trigger build), FTP / SFTP (upload/download/list/delete files), SSH (run a remote command), plus the universal HTTP Request.
• Databases — Supabase, MongoDB, Postgres, MySQL (insert / run query), Microsoft SQL Server / Azure SQL (run a query), plus the no-code databases Baserow (add a row) and NocoDB (add a record).
• Data warehouse & app database — Google BigQuery (run SQL, list datasets and tables, stream rows in) and Firebase Firestore (get, create, update, delete, list and query documents).
  • ★ BigQuery gives you named rows. Its own API returns a schema and then rows as positional arrays where every value is a string — {"f":[{"v":"a@b.com"},{"v":"42.5"}]}. This node joins the two, so you get { "email": "a@b.com", "spend": 42.5 } with real numbers, real true/false, timestamps as readable dates, and nested/repeated columns intact. It also reports bytes scanned, because that is what BigQuery bills you for — the row limit does not reduce it, so put your filter in the SQL.
  • ★ Firestore takes and returns plain JSON. Firestore's API wraps every value in its type ({"integerValue":"3"}), which is miserable to write and worse to read. Write { "seats": 3 }, read { "seats": 3 }. Update only changes the fields you list — Firestore's own default replaces the whole document and silently deletes everything you left out; that behaviour is available, but it is not the default here.
  • Both use a service-account key from Google Cloud, not the Google account you connect for Gmail or Sheets. It is your own project's robot identity, so there is no consent screen and no sign-in to keep alive.
• Amazon Web Services — one AWS connection powers all five: S3 (buckets & objects), SES (send email — needs a verified sender or domain), SNS (publish to a topic, or send an SMS), SQS (send a message to a queue) and AWS Lambda (invoke a function, synchronously or as a fire-and-forget event).
• SMS providers — Twilio, Telnyx, MessageBird, Vonage (Nexmo), Plivo, ClickSend and Sinch all send an SMS; pick whichever you already have an account with, since the node fields are nearly identical. Amazon SNS can also send one if you're already on AWS.
• More team chat — beyond Slack/Teams/Discord: Zulip (send to a stream), Matrix (send to a room), Rocket.Chat (post to a channel), Chatwork (send to a room) and Twist (add a comment to a thread). The self-hosted ones (Zulip, Matrix, Rocket.Chat) just need your server URL and a token.
• Push notifications — Pushover, Pushbullet (note to your devices), ntfy (publish to a topic — the public ntfy.sh server needs nothing but a topic name) and Gotify (your own push server). Ideal for "tell me on my phone when this happens".
• More AI — Replicate (run any hosted model — image, text, audio — and get its output) and Hugging Face Inference (text generation, classification, summarisation… on any model). Both are just an API token, and they open up thousands of models beyond the chat providers.
• AI on your own terms — Ollama (generate text, chat, embed, or list models on your own server, so the text never reaches any AI company) and Azure OpenAI (chat + embeddings from a deployment inside your own Azure tenant, for teams whose compliance rules say the data cannot leave it).
  • ⚠️ Ollama has one gotcha worth knowing before you start. Your workflow runs on Genexti's server, not on your laptop — so http://localhost:11434 points at our machine and can never work, and neither can a home/office address like 192.168.1.5. Ollama has to be reachable from the public internet: a VPS, a domain, or a tunnel such as Cloudflare Tunnel or ngrok. On the server, set OLLAMA_HOST=0.0.0.0 so it listens beyond localhost. If you get this wrong the node tells you exactly this rather than sitting there timing out. Ollama has no login of its own, so if you expose it publicly, put a reverse proxy in front and paste that proxy's token into the connection.
  • For Azure OpenAI, the Deployment name field is the name you invented in Azure AI Foundry, not the model id — if you deployed gpt-4o and called it prod-chat, type prod-chat. Keys are per-resource, so the key and the endpoint must come from the same Azure resource.
• Analytics & monitoring — Google Analytics 4 (send a Measurement-Protocol event), Plausible (fetch visitors / pageviews / bounce rate / visit duration for a period), New Relic (record a custom event for dashboards and alerts) and Grafana (add an annotation, e.g. to mark a deploy on your graphs).
• Business intelligence — Power BI (list workspaces and datasets, trigger a dataset refresh, check refresh history, push rows into a live streaming dashboard). ⚠️ A refresh is queued, not finished when the step succeeds — Power BI returns immediately. Use Get refresh history if you need to know whether it actually worked. And note two settings that cause almost every Power BI auth failure, neither of which is a wrong password: a tenant admin must turn on "Allow service principals to use Power BI APIs", and the app must be added to the workspace as Member or Admin.
• Enterprise CRM — Dynamics 365 / Dataverse (create, get, update, delete, list and search accounts, contacts, leads, opportunities, cases, tasks, or any custom table). Table names are pluralised for you — Dataverse's API wants opportunities, not opportunity. ⚠️ An Azure app alone cannot see any data: you must also create an Application user for it in the Power Platform admin centre and give it a security role.
• Advertising — Meta Ads (Facebook + Instagram): list campaigns, ad sets and ads, pull spend/impressions/clicks/CTR insights for a period, and pause or resume a campaign. Numbers come back as real numbers (Meta's API sends them as text), budgets are converted out of Meta's minor units (5000 → 50), and the account currency is returned alongside so a report can't quietly mix dollars with rupees. Paste the ad account id with or without the act_ prefix. Use a system-user token — those are long-lived and won't expire on you.
• More CRM & marketing — Copper (create/get/list people, create leads), Customer.io (identify a person or track an event) and Mautic (create/get/list contacts on your own Mautic server).
• More support & community — Zammad (create/get/list helpdesk tickets) and Discourse (create a forum topic — nice for auto-posting release notes or digests).
• Shared inboxes — Help Scout and Front, the two tools support teams actually live in. Both do the same job list: create or read a conversation, send a reply to the customer, add a note/comment only your team sees, change status or assignee, and list mailboxes/inboxes.
  • The one thing to get right in both: a note is internal, a reply is emailed to the customer. They sit one dropdown apart and you cannot unsend the wrong one — so each step's output says visibleToCustomer: true or false, which you can branch on in an If step if you want a safety check before anything goes out.
  • Help Scout has no plain API key: you create a custom app (your avatar → Your Profile → My Apps) and paste its App ID + App Secret. Genexti exchanges those for a token itself, so you never have to refresh one by hand.
  • Front ids carry their type as a prefix — cnv_ conversation, cha_ channel, inb_ inbox, tea_ teammate. Run List channels or List inboxes once and keep the id you need. Adding a comment needs a teammate id as the author, because Front records who wrote it.
• Wiki & documentation — Confluence (create, read, update and delete pages, list the pages in a space, and search with CQL). Point it at a space by its key — the ENG in …/wiki/spaces/ENG/… — and the node finds the internal id for you. Page content can be plain text (it becomes paragraphs) or HTML. Updating only the title leaves the body alone, so a rename can't blank a page.
• More commerce & payments — Gumroad (list products, fetch recent sales) and Coinbase Commerce (create a fixed-price crypto charge and get a hosted checkout link to send the customer).
• Recruiting — Greenhouse (list candidates or open jobs via the Harvest API).
• Content — Sanity (create a document in your project/dataset), alongside the WordPress/Webflow/Ghost/Contentful/Strapi/Medium nodes.
• Handy utilities — Bitly (shorten a long URL — good before sending an SMS), Bannerbear (generate an image from one of your templates, e.g. an auto-branded social card) and Gitea (open an issue on your self-hosted Git server).
• E-commerce & Payments — Shopify (multi-op: customers/products/orders — create/update/get/list/delete), Stripe (multi-op: customers/products/prices/invoices/subscriptions/payment intents), WooCommerce (create product), PayPal (create order + approval link), Square (create customer). Use test/sandbox keys while trying these — no real charges.
• Scheduling & Forms — Calendly & Cal.com (get scheduled events/bookings), Typeform & Jotform (get form responses/submissions). Pull bookings and form submissions into a flow, then process them (→ AI → email, → CRM, → Data Table…).
• Surveys — SurveyMonkey (list surveys, read a survey's questions, pull responses and collectors). ★ Its answers come back readable. SurveyMonkey's own API returns { "question_id": "10241", "answers": [{ "choice_id": "8873" }] } — no question text, no choice text — which is useless in a spreadsheet or an AI step. This node fetches the survey definition and joins it for you, so a response arrives as { "How did you hear about us?": "A friend" }. Set Readable answers to No if you want the raw shape instead (it saves one API call). Use Only responses since with a Schedule trigger so each run picks up only what is new. ⚠️ SurveyMonkey's free plan allows just 125 API calls per day, so keep the schedule hourly rather than every minute.
• Social — Bluesky, Mastodon, Reddit, LinkedIn, X (Twitter), Facebook, Instagram, Threads and Pinterest (create post/pin). Great paired with AI: Schedule → Genexti AI writes a post → post everywhere.
  • Bluesky & Mastodon connect in under a minute — no developer account, no app review. Bluesky uses an App Password (Settings → Privacy and security → App passwords); Mastodon uses an access token from your own server (Preferences → Development → New application, tick write:statuses) and works with any instance.
  • Reddit is free and needs a one-minute app of your own: reddit.com/prefs/apps → create another app → type script → redirect uri http://localhost:8080 (required but unused). The Client ID is the short string under the app name. Posts text or links to any subreddit; enter the subreddit as test, not r/test (we strip it either way). ⚠️ Reddit rate-limits new/low-karma accounts to roughly one post every few minutes, and many subreddits have their own karma or age rules — if a post is rejected you'll get Reddit's own reason in plain words. If your account has 2FA, enter your password as yourpassword:123456 with a current code.
  • LinkedIn is now a one-click Connect: create your own app at linkedin.com/developers, add the Share on LinkedIn and Sign In with LinkedIn using OpenID Connect products, add the Redirect URI the setup screen shows you (Auth tab → Authorized redirect URLs), then just paste the app's Client ID + Secret and click Connect — a popup signs you in, no manual token to generate. Post as yourself, or as a company page you administer by setting the Author URN (urn:li:organization:1234567) on the node. ⚠️ LinkedIn tokens expire after about 60 days and most apps aren't granted refresh tokens — when yours does, posts fail with a clear message and you just click Connect again to re-authorize (one click).
  • X (Twitter) needs your own X app: create one at developer.x.com, set User authentication to OAuth 1.0a with Read and Write, then copy your API Key + Secret and Access Token + Secret (four values). ⚠️ Posting to X requires a paid X API tier (Basic or above) — the Free tier is read-limited; that's X's pricing, not ours. Optionally reply to an existing tweet by its ID.
  • Facebook posts to a Page (not a personal profile — Meta doesn't allow that). Create a Meta app at developers.facebook.com, get a Page access token (permissions pages_manage_posts + pages_read_engagement, ideally long-lived), and your Page ID. Post a message and/or a link (Facebook builds the preview card).
  • Instagram publishes to an Instagram Business/Creator account linked to a Facebook Page, using a token with instagram_content_publish. You provide your IG Business Account ID and token. ⚠️ Instagram can't upload raw files — the photo must be at a public https image URL, and posting happens in two automatic steps (create → publish).
  • Threads uses a Meta Threads app (token scopes threads_basic + threads_content_publish) and your Threads user ID. Post text, or text + one image by public https URL. Also a two-step create → publish, handled for you.
  • Pinterest creates a Pin on one of your boards from a public image URL. Create an app at developers.pinterest.com, generate a token with pins:write + boards:read, and set a Board ID (on the node, or save a default on the connection). Add a title, description, and optional destination link.
• Enterprise (CRM / ITSM / ERP) — connect the big business systems and read or write their records inside a workflow:
  • Salesforce — create, update, fetch or SOQL-query any object (Lead, Contact, Account, Opportunity, or a custom __c object). Connect with your org's Instance URL (e.g. https://yourco.my.salesforce.com) and an access token from your own Connected App (Setup → App Manager → New Connected App, scopes api + refresh_token). Tokens are short-lived — refresh when one expires. Example: Webhook → Salesforce (Create Lead) → Slack.
  • ServiceNow — create, update, get or list records in any table (incident, problem, change_request, sys_user, or a custom u_ table). Connect with your instance (just dev12345 works — we add .service-now.com) and a dedicated integration user's username/password (give it a role like itil or rest_api_explorer). Example: Form/Email → ServiceNow (Create incident).
  • SAP — read and write any SAP OData service (works with S/4HANA, SuccessFactors, and SAP Gateway). Operations: Query / Get by key / Create / Update / Delete. Paste your OData service URL (e.g. …/sap/opu/odata/sap/API_BUSINESS_PARTNER) plus one auth method — a username + password (Basic), an OAuth2 Bearer token, or an SAP API Business Hub API key. Writes are handled for you (SAP requires a CSRF token — we fetch and replay it automatically). ⚠️ On-premise SAP systems must be reachable over the internet (via SAP Cloud Connector or a reverse proxy); cloud SAP works directly.

Every node is beginner-friendly by default, with an Advanced toggle for power users (raw JSON, custom cron, expressions). Integrations ship in waves — tell us which app you need next. (New in the latest waves: WooCommerce, PayPal, Square, Calendly, Cal.com, Typeform, Jotform, Mattermost, Pushover, PostHog, Segment, Mailjet, Bluesky, Mastodon, LinkedIn, Reddit, Salesforce, ServiceNow, SAP, X (Twitter), Facebook, Instagram, Threads, Pinterest, Outlook (Microsoft 365), Dropbox, Ghost, Bitbucket, Zoho CRM, OneDrive, Excel 365, SharePoint, Microsoft Teams, Box, Zoom, PagerDuty, Mixpanel, Datadog, Google Meet, Sentry, Cloudflare, Vercel, Netlify, and the 2026-07-20 waves: OpenWeather, Google Maps, ElevenLabs, OneSignal, GetResponse, MailerLite, Okta, Splunk, Customer.io, Iterable, Gorgias, BigCommerce, Razorpay, Amplitude, Opsgenie, Close — plus OpenAI upgraded to a rich multi-operation node (text/image/audio/embeddings).)

6d. The palette (finding nodes)

• + Add a step (top-left) — nodes are grouped into collapsible parent categories with a colored icon + count; click a category to expand it.
• Recently used — a strip of your last-used apps (logos) sits at the very top for one-click access.
• Search — type to filter across every node; matching categories auto-expand.

6a. 🧠 The AI Agent (reasons & uses tools)

The AI Agent is the star node. A normal AI node answers in one shot; an agent works in steps — it thinks, decides whether a tool would help, calls it, reads the result, and loops until it can answer. That means it can do things (search the web, run calculations, trigger your other workflows), not just talk.

Setup: 0. Use a saved agent (optional, top of the panel) — pick one from your Agent Library and it brings its own instructions, brain and tools with it; the settings below disappear because they now belong to the agent rather than to this step. Leave it blank to configure a one-off agent here, as before. See §6a-i just below.

1. Brain (AI model) — Genexti AI (free, no key — the default), or OpenAI / Claude with your own connected key.

2. Agent instructions (system prompt) — the agent's role, e.g. "You are a research assistant. Be concise and cite sources."

3. User message / task — what you want done, e.g. {{body.message}} or a typed instruction.

4. Tools — add as many as you like. The agent picks which to use:

   • Web Search — look up live facts/news (no setup).

   • Calculator — do exact math (no setup).

   • Date & time — get the current date/time (no setup).

   • HTTP Request — lets the agent call any API on the internet, choosing the URL and method itself. This is the tool that makes the agent open-ended: if there's no Genexti node for a service, the agent can still use its API. Two optional settings:

     • Allowed domains — e.g. api.github.com, api.weather.com. Leave blank to allow any public API; fill it in to restrict the agent to just those (subdomains count). Recommended — it means the agent can only reach services you've approved.
     • Headers — e.g. Authorization → Bearer xxx. Sent on every call this tool makes, and never shown to the AI, so your API keys stay out of the conversation.

     Requests to private or internal addresses (localhost, 10.x, 192.168.x, cloud metadata) are always blocked, even if the agent is tricked into trying — the same protection the HTTP Request node uses. Responses are capped so a huge payload can't derail the run, and failures (404s, timeouts) are handed back to the agent to react to rather than killing the workflow.

   • Sub-workflow — pick one of your saved workflows; the agent hands it data and gets its result back. This turns any workflow into a skill (e.g. "look up a customer", "create a ticket", "send a report").

5. Max reasoning steps — a safety cap (default 6) on how many tool calls it may make before it must answer.

6. Memory — off by default, so every run starts fresh. Switch it to Remember this conversation and the agent sees the recent back-and-forth, which is what makes follow-ups work: "What's the weather in Karachi?" → "And tomorrow?" The second question only means something if it remembers the first.

   • How much to remember — the number of past messages kept (default 10). Older ones drop off, so a long-running agent never grows without limit.
   • Separate conversations by — leave blank and the agent has one shared memory. Set it to something like {{body.chatId}} or {{body.from}} and every customer gets their own separate conversation, which is what you want for a support bot serving many people through one workflow.

   Memory is stored per user, per workflow, per agent node — it can never leak between accounts, and only the questions and answers are kept (not the tool trail). The run output shows memory: { session, recalled, window } so you can see exactly what it remembered. If the database is briefly unavailable the agent still answers; it just doesn't recall that turn.

7. Answer format — leave as Text for a normal written reply. Switch to Structured JSON when the answer needs to feed the next step rather than be read by a human, and describe the fields you want:

   {
     "name": "the person's full name",
     "email": "their email address",
     "urgency": "high, medium or low"
   }
   

   The key is the field name, the value describes what belongs in it. You then use the results directly downstream as {{data.name}}, {{data.email}}, {{data.urgency}} — e.g. straight into a Google Sheets row or an IF node that routes urgent tickets differently.

   If the agent genuinely can't determine a field it returns null for it rather than inventing something. And if it fails to produce valid JSON at all (it gets one retry), data stays null and dataError explains why — you'll never receive a made-up object.

Output: {{output}} (the final answer) plus {{steps}} — the full thought → action → observation trail. The run panel opens on the 💬 Answer view so you can read the reply straight away; switch to ▤ Table / ⑂ Schema to inspect exactly how the agent reasoned and which tools it used.

Example — a research assistant: Manual trigger → AI Agent (Brain: Genexti AI · instructions: "Answer with current facts, cite sources" · task: What are the top AI news stories today? · tools: Web Search) → Send Email with body {{output}}. The agent searches the web, reads the results, and writes you a briefing — end to end, no key.

Tips: give each tool a clear name + "when to use it" description so the agent chooses well; keep Max steps modest to control cost/time; the agent recovers from a failed tool (the error is fed back to it) instead of breaking the run.

Under the hood: the agent uses real tool-calling, so it reliably uses the tools you give it (e.g. it will actually search the web for a "today's news" question rather than guessing from memory) and won't present outdated info as current. On the free Genexti AI brain it runs on our managed AI at no cost to you; if you pick OpenAI/Claude it uses your connected key.

6a-i. 🤖 The Agent Library (build an agent once, use it everywhere)

An agent used to live inside a single step. If you wanted the same assistant in three workflows, you filled in the same instructions three times — and improving it meant editing all three. The Agent Library (Flow → Agents in the sidebar) makes an agent a named thing you keep.

Create one: Flow → Agents → New agent. Give it a face (an emoji, so a list of agents is scannable), a name, a note on what it's for, its instructions, its brain, and how many reasoning steps it may take. If your library is empty you'll be offered four starting points — Support Replier, Content Writer, Researcher and Classifier — which you can change completely.

Use one: on any AI Agent step, open Use a saved agent and pick it. That's the whole setup — you then only supply the task (User message / task) and, if you want it, memory.

What travels with the agent, and what stays on the step

That split is the useful part: the same agent can answer support mail in one workflow and summarise tickets in another, because the job it's given belongs to the step, not to the agent.

Edit once, changes everywhere. Update an agent in the library and every workflow using it picks that up on its next run — there is nothing to republish.

Good to know

• Deleting is guarded. If workflows still point at an agent, Genexti tells you how many before letting you delete it, so a step can't quietly lose its brain.
• If an agent goes missing (deleted, or not yours), the step falls back to whatever settings are on the node rather than failing the run.
• Blank fields in the library don't wipe the step — only values the agent actually has are applied.
• Tools travel with the agent too — set them in the library and it takes them into every workflow. An agent that can search the web should be able to do that everywhere, not only where it was first built. The Researcher preset ships with Web Search and Date & time already on.

6b. 🔎 How Web Search works (no keys, no limits)

The Web Search node — and the agent's Web Search tool — need no setup from you, and there is no monthly search quota. Genexti runs its own search infrastructure and tries several sources in order, using the first one that returns results:

1. Genexti Search — our own self-hosted metasearch engine. It queries Google, Bing, DuckDuckGo, Brave and 70+ other engines at once and merges the results. Unlimited, and it handles live news and current events.
2. Backup search providers — used only if step 1 is briefly unavailable, so searches keep working.
3. DuckDuckGo + Wikipedia — a final free fallback. Good for general knowledge, but not live news.

Asking for news gets you actual news. A general web search returns landing pages ("CNN: Breaking News") which carry no date. So when your query is about current information — it mentions news, latest, today, breaking, headlines, current, recent — Web Search automatically switches to news sources and returns real dated articles instead. Then, because search engines do sometimes hand back very old articles:

• results older than 60 days are discarded for these queries, so a 2012 article can never be served up as today's news;
• what's left is sorted newest first;
• each result carries a published date, shown in the answer text as (published 2026-07-21).

The node's {{source}} output tells you which path ran — searxng-news for the dated-article path, searxng for a general search — which is handy when debugging. If a search genuinely finds nothing, the node says so plainly rather than inventing an answer, and when an AI Agent gets an empty search result it will tell you it couldn't find current information instead of falling back on stale training data.

The AI Agent is also told today's real date on every run, and asked to cite each story's publication date. Without that, a language model dates "today" from its training data — which is how a briefing of genuinely current stories can end up wrongly headed with a year-old date.

Operators (self-hosting Genexti): this chain is configured with the server env vars SEARXNG_URL (recommended, unlimited) → TAVILY_API_KEY → SERPER_API_KEY → BRAVE_API_KEY. Setup instructions, including the Docker command for SearXNG, are in CONNECTIONS-SETUP.md.

6c. ⏸️ Wait for a Person (approvals & human-in-the-loop)

Some things shouldn't happen automatically — issuing a refund, sending a contract, posting to the company account. Wait for a Person puts a human in the middle of the workflow.

How it works

1. The step sends your question to someone on Email, Slack, Discord or Telegram.
2. The workflow pauses. Nothing after this step runs — no emails, no charges, nothing.
3. They click ✅ Approve or ❌ Reject (or type a reply) on a simple page.
4. The workflow carries on from exactly where it stopped, and later steps can use their answer.

Settings

• Ask them on — Email / Slack / Discord / Telegram. Slack and Discord accept either a saved connection or a plain webhook URL.
• What to ask — your question. Supports {{templating}}, e.g. Approve a refund of {{body.amount}} for {{body.customer}}?
• They can — Approve or Reject (two buttons), Approve only (one), or Reply with text (a box they type into — handy for "what should I reply to this customer?").
• Give up after (hours) — default 48. After that the link stops working and the run is marked as timed out, so nothing sits pending forever. Blank or 0 waits indefinitely.

Using their answer — the steps after it receive:

• {{answer}} — what they chose (Approve / Reject) or the text they typed
• {{approved}} — true or false, ideal for an If / Branch step right after

A typical shape: Webhook → AI writes the reply → Wait for a Person → If approved → Send it.

What you'll see while it's paused. The run bar turns amber: ⏸ Waiting for a person — "Paused — the rest runs the moment the person you asked answers." The waiting step shows ⏸ waiting for an answer… and gets an amber badge on the canvas; every step after it simply hasn't run yet. This is a healthy run, not a failure — a paused workflow is holding its place, and it will finish itself the moment the answer arrives. Watch Executions for the completed run, where the following steps show {{answer}} and {{approved}} filled in.

Good to know

• The approver needs no Genexti account and nothing installed — the link is all they need.
• The link contains a long random one-time token, and it stops working the moment it's used.
• The pause is saved to the database, not held in memory — an approval still works after a server restart, a deploy, or a week of waiting.
• It can't be used inside a Loop Over Items (that would mean one pending approval per item); put it before or after the loop. You'll get a clear message if you try.
• If the message can't be sent (bad address, missing connection), the run fails clearly instead of pausing forever waiting on a message nobody received.

6d. 📌 Pinned & mock data (test without re-calling real services)

While you're building, running the workflow over and over means calling the same services over and over — burning paid API credits, re-sending test emails, hitting rate limits. Pinning fixes that.

Pin a real output — run the step once, open it, and click 📌 Pin this output under Last output. From then on that step returns the saved result instead of running. A 📌 badge appears on the node so you can see it at a glance.

Or write mock data — open the step, expand ⚙️ Advanced at the bottom of the settings panel, click Add mock data and type any JSON. Now you can build and test all the steps after a node before that node even works: fake the shape you expect and carry on.

To go back to normal, open the step → ⚙️ Advanced → Unpin — run it for real again.

Where to find it: pinning lives under ⚙️ Advanced, collapsed by default, because a normal workflow never needs it. It opens by itself — with an amber "in use" tag — the moment a step is pinned, so a pin can never quietly hide from you.

The important rule: pinned data is used only when you press Test/Run yourself. Live schedule and webhook runs always call the real service. So you can't accidentally leave a pin in place and have your production automation quietly serve fake results — a mistake that would be very hard to notice.

And whenever a run used pinned data, the run bar says so directly: 📌 N steps pinned — not really run, right beside Run succeeded. A mocked run can never be mistaken for a working one.

Invalid JSON is flagged as you type, and the run stops with a clear message rather than passing broken data down the workflow.

7. Passing data between steps ({{templating}})

• A step receives the previous step's output as input.
• Easiest way: when editing a node, an "Insert data from previous step" row shows clickable chips (e.g. {{text}}, {{body.email}}) — click one to drop it into the field. No need to remember field names.
• Or type {{field}} yourself to insert it into another node. Examples:
  • After a Genexti AI node, use {{text}} (the AI's answer) in an email body.
  • After a Web Search node, use {{answer}} (a readable summary of the results).
  • After an HTTP node, use {{body.something}}.
• Example email body: Here is your quote: {{text}}
• Handy built-in values (work in any {{ }} field):
  • {{$now}} — current date & time (ISO) · {{$today}} — today's date (YYYY-MM-DD) · {{$time}} — current time (HH:MM:SS)
  • {{$timestamp}} — a unix timestamp · {{$uuid}} — a fresh unique ID · {{$random}} — a random number
  • Example: a Google Sheets row { "id": "{{$uuid}}", "when": "{{$now}}", "name": "{{body.name}}" }
• Reusable values: {{vars.KEY}} inserts a workflow Variable (set them under Flow → Variables).

7a. Tidying a value: helpers

Add a helper to the end of any {{ }} expression to reshape the value without needing a Code step.

• Lists → text: {{items.join(", ")}} → apples, pears, figs. This is the one people reach for most — a list looks like ["a","b"] in an email until you join it.
• Text: {{name.upper()}} · {{name.lower()}} · {{name.trim()}} · {{name.title()}} (Title Case) · {{text.replace("old", "new")}} (replaces every occurrence) · {{text.slice(0, 40)}} · {{email.split("@").last()}} → the domain · {{q.urlencode()}} for building a URL
• Numbers: {{price.round(2)}} · {{n.floor()}} · {{n.ceil()}} · {{n.abs()}}
• Lists: {{items.first()}} · {{items.last()}} · {{items.length()}} (character count for text)
• Dates: {{when.format("DD MMM YYYY")}} → 31 Jul 2026. Tokens: YYYY MM DD HH mm ss, plus MMM/MMMM for month names and ddd/dddd for weekdays. Works on the built-ins too: {{$now.format("DD/MM/YYYY")}}
• Blank fields: {{name.default("there")}} → uses there when the field is missing or empty. Ideal for Hi {{name.default("there")}}, so an email never opens with "Hi ,".
• Chain them: {{name.trim().upper()}}

If you mistype a helper, nothing breaks. An unrecognised one is ignored and the value passes through as-is — a typo in one field never takes down a running workflow.

7b. Knowing which run you're in

• {{$workflow.name}} · {{$workflow.id}} — the workflow this step belongs to
• {{$execution.id}} — the ID of this run. Put it in a log row, a ticket or an email footer and you can match a message back to its exact run in Executions.
• {{$execution.mode}} — what started this run (manual, webhook, schedule…)
• {{$execution.startedAt}} — when the run began

A paused Wait for a Person step keeps the same $execution.id when it resumes — one run, one ID, so a follow-up email still matches the first one.

⚠️ Note the $. A plain {{workflow.name}} still reads a field called workflow in your data — only {{$workflow.name}} means the run's metadata.

8. Running & seeing results

• Click Run ▶ (top right).
• Before it runs, Genexti quickly checks for common mistakes (no trigger, or a step whose app isn't connected) and, if it finds any, shows a friendly "Before you run…" note telling you exactly what to fix — no more confusing mid-run errors. (You can still Run anyway.)
• The bottom bar shows ✅ Run succeeded + a preview of the final output.
• Click any node after a run → its Last Output (or error) shows in the right panel.
• Run to here — right-click any step → ▶ Run to here to run the workflow only up to that step and inspect its output, without triggering the steps after it. Perfect for testing your logic without actually sending the email / posting the message yet.
• Runs (top bar) → full history of every run, with each step's result.

7c. Keyboard shortcuts on the canvas

Once you've built a few workflows, these are faster than reaching for the mouse. They work when the canvas has focus — if you're typing in a field, every key stays a normal key, so nothing is hijacked mid-sentence.

The arrow keys follow your wiring first, not just what's nearest on screen, so → always walks the order the workflow really runs in. Only when a node has no connection in that direction does it fall back to whatever is closest.

8a. The output panel — Answer / Preview / Table / Schema / JSON

When you click a node after a run (or open a step in the run log), its output shows in a tabbed panel. The panel opens on whichever view fits the data, so you normally don't have to pick:

• 💬 Answer — for anything that produced text: an AI Agent's reply, a Genexti AI response, a Web Search summary. You get the answer laid out to read, full width and full length, with small chips underneath for the extra fields (e.g. steps: 4). This opens by default for text results, because a table is the wrong shape for one long answer — tables are for lists.
• 🖼 Image / 🔊 Audio — if a step produced an image (e.g. OpenAI → Image → Generate) or audio (OpenAI → Audio → Speech, ElevenLabs), it's shown as a real rendered preview with a ⬇ Download button — not a wall of code. This tab is selected automatically when media is present.
• ▤ Table — when a step returns a list of records, you get a clean rows-and-columns table, and it opens by default. Long values are shortened (hover to see the full value); the first 50 rows are shown. It stays available for single results too, if you prefer it.
• ⑂ Schema — a field tree of the output with each field's type (string, number, array [3], object…). Great for discovering exactly what field names to use in {{ }} templates downstream.
• { } JSON — the raw JSON. Very large values (like image base64) are collapsed to « N chars » here so the panel stays readable — the full data still flows to the next step and is available in the Preview/Download.

The full, untrimmed result always flows to the next step regardless of which tab you're viewing — the tabs only change how you inspect it.

8c. 🕘 Version history (undo a bad edit, even days later)

Click History in the editor's top bar to see earlier versions of the workflow and put one back.

• A restore point is kept as you edit — at most one every 10 minutes. The editor autosaves a few seconds after every change, so saving a version each time would bury the one you actually want under hundreds of near-identical entries. Ten-minute spacing gives you "an hour ago", "yesterday".
• Only structural changes count. Renaming, favouriting or activating a workflow doesn't spend a restore point.
• The last 20 are kept per workflow.
• Restoring is itself undoable — your current version is saved first, and appears in the list marked Before the restore.
• Restoring replaces the steps, connections and sticky notes. It doesn't touch your Connections, variables or run history.

8b. ✨ Understand & fix with AI

• Explain (top bar) → AI describes, in plain English, what your workflow does step by step, plus a tip.
• When a run fails, an "Explain & fix" button appears in the red result bar → AI tells you why it failed and exactly how to fix it (which step, which field). No more decoding raw errors.

8d. ⚙️ Reliability (retry & continue on fail)

Real APIs sometimes hiccup. Click any step → scroll to the bottom of its settings → expand ⚙️ Advanced → the ⚙️ Reliability section. (It's collapsed by default so a first workflow isn't buried in options, and it opens by itself whenever any of these is switched on.) You get:

• Retry automatically if this step fails — retries the step up to N times (with a wait you choose) before giving up. Perfect for flaky APIs or rate limits.
• Continue the workflow even if this step fails — instead of stopping everything, the step's error is passed to the next step (as {{error}}) and the workflow keeps going. Great for non-critical steps.
• Timeout (seconds) — if a step hangs longer than this, it's stopped (and counts as a failure, so Retry/Continue still apply). 0 = no limit.
• Give this step its own "on error" path — a second, red output appears on the node. Wire it to whatever should happen when that step fails: alert the team, try a different service, write a fallback value, open a ticket. The workflow keeps running down the error branch instead of stopping.
  • Only one of the two paths ever runs. On success the error branch is skipped; on failure the normal path is skipped.
  • The failed step passes on {{error}} (the message) and {{failed}}, so your alert can say what actually broke.
  • Inside a Loop Over Items, a failing item takes the error path and the loop carries on with the next item.
  • How it differs from the two settings above: Retry tries the same step again · Continue pushes the error down the normal path and hopes later steps cope · an error path gives the failure its own steps. If you want a real fallback, use the error path.

Together these make your automations far more robust — a momentary glitch, a slow API, or a hung request no longer breaks the whole run.

9. Webhooks (connect external apps / your IDE apps)

1. Add a Webhook trigger → click it → copy the Webhook URL.
2. Toggle the workflow to Active → Save.
3. Call that URL from anywhere (your website, your IDE-built app, another service). Each call runs the workflow. The incoming data is available as {{body}}, {{query}}.

10. Schedules

1. Add a Schedule trigger → set the cron (e.g. 0 9 * * * = 9am daily).
2. Time zone — new schedules default to your time zone, so "9am" means 9am where you are, not on our servers. Change it (e.g. for a team in another country) or clear it to use UTC.
3. Toggle Active → Save. It now runs automatically on schedule.

8c. ✨ Ask AI — edit a workflow by chatting

• Inside the editor, click Ask AI (top bar) to open a chat panel. Type a plain-English change — e.g. "add a step that also posts this to Slack" or "only email me if the amount is over 100".
• AI updates the current workflow (adds/edits/connects the right steps) and replies with what it changed. It's a conversation — your messages stay in the panel, so you can keep refining.
• Every change has an "Undo this change" button, so you can safely experiment. This is different from Build with AI (which makes a workflow from scratch) — Ask AI edits the one you're on.

11. Managing workflows (the hub)

The /flow dashboard is your workflow hub:

• Stats strip at the top — Workflows, Active, Total runs, Failure rate (the last two link to Executions).
• Search / Sort / Filter — search by name, sort by Last updated / Name / Newest, and filter tabs All / Favorites / Archived.
• Each card's ⋮ menu: Open · Favorite (pin to the top) · Duplicate (make a copy) · Rename · Tags · Download (save as a .json file) · Archive (hide without deleting) · Delete.
• Import (top bar) — bring in a workflow from a .json file. See the box below for exactly which files work.
• 🏷️ Tags — label workflows by client or project (e.g. Acme Corp). Tag chips show on the cards and in a filter row; click one to see only that client's workflows. Great for agencies managing many automations.

📥 What can I Import? (which file, and how)

The Import button (top-right of /flow) accepts a .json file — two kinds:

1. A Genexti workflow — a file you got from the Download option on any workflow card (named …​.genexti.json). This restores it exactly: every step, connection, note and tag.
2. An n8n workflow — a workflow exported from n8n (in n8n: open the workflow → ⋯ menu → Download, or Ctrl/Cmd-A → copy → paste into a .json file). Genexti auto-detects the n8n format and converts it for you: it maps each n8n step to the matching Genexti step, rebuilds the connections (including the True/False paths on an If), and turns n8n sticky notes into canvas notes.
3. An n8n TEMPLATE from the n8n.io gallery — the file you get from a template page rather than from your own n8n. ✅ Fixed 2026-07-29. These arrive wrapped in extra layers of template metadata (title, author, categories), and until this fix Genexti looked only at the top level, found no steps, and answered "No recognizable steps found in that file" — on the file most people try first. Import now digs down to the real workflow whatever it is wrapped in, and the template's own title comes across as the workflow name instead of a generic "Imported n8n Workflow".

How the n8n conversion works — and its limits:

• Steps Genexti has an equivalent for (HTTP, Webhook, Schedule, Set, If, Switch, Code, Gmail, Telegram, Slack, Notion, OpenAI, the AI Agent, and 200+ more) come across automatically.
• Steps Genexti doesn't have yet are left out, and we tell you exactly which ones on a yellow banner. Everything else still imports — you just re-add or reconnect those few pieces.
• AI sub-steps are counted separately, and they are not losses. n8n builds an AI agent out of a cluster of extra steps wired into it — the chat model, the window memory, the embeddings, the vector store, the text splitter. Genexti's AI Agent holds all of that inside one step, so those pieces have nothing to map to. The banner now says so in its own sentence rather than listing them next to genuinely missing integrations. When you open the workflow, set the brain and memory on the AI Agent step itself. (Tested against three real n8n.io templates: every single skipped item was one of these — not one missing integration between them.)
• Settings inside each step are carried over where the field names line up; anything that doesn't match is left blank for you to fill in. Always open the imported workflow and check each step's settings and connections before switching it on.

If Import fails:

• "That file isn't valid JSON" → you uploaded the wrong file (e.g. a screenshot, a .txt, or a half-copied file). Re-export the workflow and upload the fresh .json.
• "That n8n workflow only uses steps Genexti doesn't have yet" → none of its steps have a Genexti equivalent yet. Build it with Build with AI instead, or tell us which app you need.

🟢 Active vs. Inactive (turning a workflow on)

Active/Inactive is the on/off switch for a workflow's automatic triggers — it decides whether the workflow runs on its own.

• Active = triggers are live. A Schedule trigger fires on its clock (our scheduler checks every 60 seconds and only runs active workflows), and a Webhook trigger accepts incoming calls.
• Inactive = the workflow is saved but its triggers are asleep. The scheduler skips it, and anyone hitting its webhook URL gets "Workflow is not active. Activate it to accept webhooks."
• Important: Inactive does not mean broken. You can still open, edit, and Run now manually at any time — manual runs ignore the Active switch. Active only controls automatic triggering.
• New and duplicated workflows always start Inactive on purpose, so nothing fires while you're still building. Flip it to Active (the toggle on the card or in the editor) when it's ready to run live.
• The hub's Active stat and the green dot on a card tell you which workflows are currently live.

📦 Archive vs. Unarchive (tidying your list)

Archiving is about organizing your list — it has nothing to do with running.

• Archive = hide a workflow from your main list without deleting it. Every step, connection, note and run-history stays safe; it just moves out of the way. Perfect for old or seasonal automations you don't want cluttering the view.
• Unarchive = bring it back to the main list. The hub has an Archived filter tab where archived workflows live; open one and unarchive to restore it.
• Archiving is not deleting — think Archive = move to a drawer, Delete = throw in the bin. (An active workflow keeps running even if you archive it, so deactivate it first if you want it to stop.)

⭐ Favorite (pin the ones you use most)

• Favorite pins a workflow to the top of your list and adds it to the Favorites filter tab. Purely for quick access — it doesn't change how the workflow runs.

🏷️ Tags (group by client or project)

Free-form labels to organize workflows once you have a lot of them.

• Add your own labels via a card's ⋮ → Tags — e.g. a client or project name like Acme Corp, Marketing, or Internal.
• Tag chips show on each card, and a filter row appears — click a tag to see only that group's workflows.
• Built for agencies / anyone managing many automations: tag everything for one client with their name, then filter to just their work in one click.
• Tags are purely for finding and grouping — they have zero effect on whether a workflow runs.

Quick mental model:

11b. 🔌 Connections (connect your apps)

• The Connections tab (sidebar) is where you link apps like OpenAI, Slack, Notion, Airtable, Stripe, and Google (Gmail/Sheets/Calendar).
• API-key apps: paste the key once — it's encrypted and reused by that app's nodes.
• Google/Slack: click Sign in and authorize — no keys to copy.
• One-click Connect (your own app): some apps — starting with Dropbox — use a Connect popup. You paste your app's key + secret once, then a provider window opens to authorize, and we keep your access token fresh automatically (no expiring tokens to babysit). The setup screen shows the exact Redirect URI to add to your app. After saving, if you ever see "Finish connecting", just click it to complete the authorization.
• In a node, credential fields auto-fill with your saved connection, so you rarely pick manually.

11c. 🔤 Variables (reusable values)

• The Variables tab lets you save a value once and use it everywhere — e.g. your company name, a support email, an API base URL.
• Reference one in any node field by typing {{vars.NAME}} (there's a one-click copy button on each variable). Change it in one place and every workflow updates.
• For secrets (API keys), use Connections instead — those are encrypted.

11d. 📊 Executions (run history)

• The Executions tab shows every run across all your workflows, newest first, with status (Success / Error / Running), trigger, time and duration.
• Filter by All / Errors / Success. Delete a single run, or Clear failed / Clear all.
• 🔁 Retry — re-run the current saved version of a workflow from its history.
• ✨ AI Fix (on failed runs) — AI reads the error and either (a) fixes it for you automatically (config/logic mistakes) or (b) tells you exactly what you need to do (e.g. add a webhook URL, connect an account) and sends you to the right place. Then Retry.

12. 🗄️ Data Tables (store data between runs)

Data Tables are persistent stores your workflows can write to and read from — for leads, logs, results, or lists you check against. A table has columns (like a spreadsheet) and rows.

Create a table

1. Sidebar → Data Tables → New table.
2. Name it (e.g. Leads) and add columns (e.g. name, email, status) → Create.
3. You can Add row and edit cells right on the page (click the green ✓ to save a row).

Use it in a workflow — the whole point:

• Save data → add a Data Table — Add Row node, pick your table, and it stores a row. Either map the fields as JSON ({ "email": "{{body.email}}", "status": "new" }) or leave it blank to auto-store the incoming data.
• Read data → add a Data Table — Get Rows node, pick your table (optionally match a column to a value, e.g. status = new). Its output gives you {{rows}} (the list), {{count}} (how many), and {{items}} (use with Loop Over Items to act on each row).

Simplest example to try (2 steps): Manual trigger → Data Table — Add Row (pick Leads, put { "name": "Ali", "status": "new" } in Row data) → Run → open Data Tables → the row is there. Then swap in Get Rows to read it back. Once that clicks, connect a Webhook (form) → Add Row to capture real submissions.

13. Sending real emails

• The Send Email node works out of the box (sending is handled for you).
• Fill To, Subject, Message. Optionally set a Sender name (defaults to "Genexti").
• Use {{text}} in the message to include AI output.

14. Plans & limits

• Free: trial (about one workflow). Paid: more/unlimited workflows.

15. FAQ / troubleshooting

• "Email failed: API key is invalid" → leave provider settings alone; sending is handled for you. If you typed a placeholder, clear it.
• Webhook returns {"success":true,...} → that means it worked — the call triggered the workflow. Check Runs.
• Schedule isn't running → make sure the workflow is Active and the cron is valid.
• A node shows ✕ → click it to see the error in the right panel; fix that node's settings.
• Can't see the AI's output → click the node after running; it shows under "Last Output".

TODO (expand later)

• Screenshots/GIFs per step.
• A library of ready-made workflow templates.
• More nodes (Slack, Google Sheets, etc.) as they're added.
• "Connect Flow to your Genexti website/app" tutorial.
• Video walkthrough.