Reasoning vs. Speaking: Building Channel-Agnostic Agents with n8n

Building AI agents can quickly become complex and confusing. At Bitovi, we're always looking for ways to streamline efforts for all of your production use cases, not just that first POC. That's why we've developed techniques to help ensure your agents don't get confused as you scale and give them more to do.

In this post, we'll discuss one technique that we've used repeatedly with our clients, and it has been very powerful in terms of an ongoing effort: Surface & Core layers.
Continue reading to learn how to create robust agents with Bitovi's multi-layer approach!

Why use n8n?

Building agents that evolve from a simple webhook to an autonomous teammate requires three capabilities:

1. Composable sub‑workflows – drag a step, feature, or entire capability in or out of the agent without edits elsewhere.

2. Graph‑native branching – splice classic if/else logic beside LLM calls on one canvas.

3. First‑class data exchange – HTTP, queues, DBs, and LLM nodes live side‑by‑side so the agent fits your existing stack.

n8n delivers all three, giving you clean separation of concerns inside a powerful visual workflow building interface. You iterate faster, debug quicker, and spend time on outcomes, not scaffolding.

Two Layers, Many Surfaces

Bitovi has developed a flexible technique that cleanly separates how your AI Agents communicate from how your AI Agents reason. By carving every assistant into two defined layers, you keep logic clear, make testing simpler, and unlock rapid channel expansion—without rewriting the brains.

Split the stack into two concerns:

• Surface layer – speaks the language of the channel (Slack, email, voice). It adapts a snippet of user input into a normalized chat history for the core, then renders the core’s reply back into channel‑specific markup.

• Agent Core – owns intent routing, tool orchestration, and persona. It never cares where the request came from or where the answer is going.

BitBot anecdote – We launched BitBot in Slack, so we already has a Slack Surface workflow. When we needed to support Gmail, we essentially cloned the Slack Surface workflow, swapped the trigger (Slack webhook -> Gmail trigger), the thread fetch request (Slack thread -> Email chain), and core output formatting (Slack Blocks -> HTML email) and pointed both at the same Agent Core. No core edits. No redeploy.

Surface Layer

A Surface workflow follows a short set of steps to connect the Agent Core to the outside world:

1. Input – Trigger fires with a message snippet.

2. Enrich – Fetch the entire conversation thread, email chain, or voice transcript.

3. Normalize – Convert to a simple array of strings: `["user1: something user1 said", "user2: something user2 said"]`.

4. Query Core – Pass {query, history} to the Agent Core sub‑workflow.

5. Render – Turn Agent Core response into Slack Blocks, HTML email, or whatever output is required for the output medium.

6. Output – Post or speak the reply.

Because every step lives in an isolated node or sub‑workflow, the Surface layer can evolve independently—adding channel‑specific security, observability, and rendering logic—while the Core stays stable and audit‑friendly even as you introduce entirely new modalities.

Examples

• Slack Surface – Webhook ➜ conversations.replies ➜ Flatten ➜ Core ➜ Format(Block Builder) ➜ chat.postMessage.

• Email Surface – IMAP webhook ➜ Thread Stitcher ➜ Flatten ➜ Core ➜ Format(HTML Template) ➜ SMTP node.

• Voice Surface – Telephony trigger ➜ transcript ➜ Flatten ➜ Core ➜ Format(Audio-friendly script) ➜ respond to webhook ➜ ElevenLabs TTS ➜ call leg.

Agent Core

The Agent Core is the system’s reasoning engine—one channel‑agnostic brain that enforces policy, routes intent, and orchestrates tools. Because every Surface funnels requests through this core, you can enhance capabilities or tighten controls in a single place and instantly benefit every channel:

• Guards the gates – Hard routes sensitive requests based on ACL, project, or channel.

• Routes with semantics – A small LLM classifier labels the intent (doc search, ticket triage, general chat, etc…).

• Delegates work – Each intent points to either a deterministic sub‑workflow (rule‑based) or a sub‑agent (tool‑calling).

• Falls back gracefully – Unhandled intents go to a “helpful GPT‑4o” fallback, for example, or perhaps you fall back to a more generally helpful agent with broader capabilities.

Beyond those layers, basically every feature is simply another sub‑workflow (you can think of them as functions), so you can promote, demote, disable, or introduce features in a very modular approach.

Dancing Along the Intelligent‑Automation Spectrum

Bitovi’s Core layer design works like a dimmer switch—you can start with deterministic scripts for critical paths, add semantic routing as confidence grows, and end with fully agentic workflows that plan, critique, and iterate. All three modes live inside the same Agent Core, so shifting left or right on the spectrum never touches surface code.

1. Rule‑Based Automation – “if X, do Y.” Hard if/else branches call fully‑deterministic sub‑workflows—ideal when auditability or uptime is higher priority than flexibility.

2. Intelligent Automation – “if it sounds like X, do Y.” A small LLM classifier labels intent and chooses the branch, removing brittle string matching without giving full autonomy.

3. Agentic Execution – “here’s the goal, figure it out.” The Core receives a goal plus a toolbox, then iterates with planning and self‑critique until it meets the objective.

Because rule logic, classifiers, and tool‑driving sub‑agents all sit side‑by‑side in the Core, you can progressively migrate any task along this spectrum as risk tolerance changes.

Design Benefits

By isolating communication concerns from reasoning logic, you unlock several engineering superpowers:

• Channel Agility – Add Slack, Email, Voice, or SMS tomorrow.

• Progressive Reliability – Start scrappy; harden high‑risk paths over time.

• Clear Observability – Errors localize to a layer, making on‑call happier.

• Security First – Surface strips PII and enforces auth before the LLM sees data.

Taken together, these strengths let you release faster today and refactor safely as needs evolve.

Next Steps

Ready to explore multi‑layer agents or level‑up an existing workflow? Start here:

• ⚡  AI Adoption Workshop – Map, prototype, and de‑risk your highest‑value automation.

• 🤝  n8n Consulting – Learn how we co‑build robust agent frameworks with n8n. 

• 📞  Architecture Chat – Book a free 15-minute call to talk edge‑cases.