Build Your Team's Automation Layer: The AI Glue Agent Pattern

Hello, thank you for joining my talk. My name is Shubh Ravishankar Gawhade, and I specialize in bridging technical architecture to build software for global organizations. My work focuses on transforming complex challenges into efficient, user-centric systems by architecting pipelines that turn human intent into scalable products.

In almost every organization, there is still a hidden rule. The glue person, this isn't a job title, is the person who becomes the human API between your tools. The one who's paying to just run the script, manually export that report, or copy updates between Jira, Shields, and a status doc. It looks like productivity, but it's actually a tax on your most expensive resource, deep uninterrupted focus. Cognitive science and engineering practice both show just how fragile that focus is. Once an engineer is in deep flow, a single interruption can shatter that state.

Studies consistently find that regaining full immersion in a complex task takes around 20 to 30 minutes. Add attention residue, where a part of your mind is still stuck on the previous task. This effect is further amplified by daily meetings and the time spent in preparing for them. Each quick ping quietly burns a significant chunk of your day, resulting in fewer hard problems being solved, more bugs, and a culture that rewards interrupt-driven responsiveness over strategic contributions.

I learned this the hard way. In my Honors narrative project, our story lived in Twine. Audio assets lived elsewhere, and our game code was littered with functions triggered by dialogue IDs. Each change turned into a forensic investigation. Search the code, cross-reference with Twine, DM the narrative lead to confirm the update, rebuild, and hope nothing else broke. The system was optimized for the first version, not the second. It was built for creation, not iteration. That pain compounded when I started working on multilingual educational narrative projects for global organizations and audiences.

Suddenly, our content had to work in English, Hindi, Thai, and Burmese, and more. For some engines, we couldn't paste text directly. Non-Latin scripts required encodings like Krithidev for Hindi, Zoggi for Burmese, and Thai vowels would render incorrectly without manual glyph correction. The challenge was no longer just story logic. It was the entire pipeline, from narrative to encoded rendered content.

So I built a collaboration plane, a Google Sheet, as the single source of truth for production. Each row became a narrative unit, a tutorial step, a line of dialogue, a branching choice node. Some of the columns that were captured are dialogue ID to decouple narrative from the code, UI type and speaker to drive UI, animation, and speaker info. HasChoice and LinkedDialogueID to define branching as data, not code. Localized text columns for English, Hindi, Burmese, etc. So translators worked in context. Encoding columns for engines that needed specific fonts or glyph mappings.

This sheet became a contract between disciplines. Writers saw a script with structure, designers saw a tunable graph. Translators worked in context, and developers consumed structured data instead of chasing hard-coded IDs. The chaos of what and which version is live disappeared, but a new problem emerged. Every time a translator finished a column or a writer fixed a typo, the message came. The sheet is updated, can you please run the build? I had become the glue person for my own system, exporting CSVs, running encoding and validation scripts, triggering builds, and sanity checking outputs.

I had solved data fragmentation and personified process fragmentation. The collaboration plane captured what should happen, but the how still ran through my inbox. Once you see that pattern, you see it everywhere. The glue person is the developer who must just deploy it. The analyst who must just refresh the dashboard. The PM who must reconcile tickets between tools. They become a single point of failure, risk being a bottleneck, and hit an invisible career ceiling.

Valued for always being available, but unable to step away to design better systems. So the key question becomes, if we have automated our infrastructure and our deployment, why is orchestration, the layer in between, still manual? That question crystallized into a pattern. Collaboration plane plus AI glue agent. The collaboration plane is a human readable source of truth. A sheet, notion database, or backlog where humans declare intent in a shared structured way. The AI glue agent is the automated orchestrator that watches the plane and executes the predictable work, calling APIs, running scripts, triggering pipelines.

The magic is in decoupling. You stop being the glue and instead become the architect of the glue. Your role shifts from executor to orchestrator. To make this concrete, let me show you this pattern running end-to-end in a different domain. A self-hosted AI stock analyst that autonomously produces a weekly investment memo. Here, the collaboration plane is a Google Sheet, which not only stores a list of stocks and their tickers, it encodes my strategy. Each row represents a stock with live data, with tickers updated through Google Finance. Technical integrators like exponential moving averages computed with spreadsheet formulas.

A low percentage column measures how close the stock is to its 52-week low, offering a simple yet effective strategy. The sheet acts as a declarative specification, analyzing top stocks near their 52-week lows every Monday. An N8n workflow, containerized with Docker, serves as the AI glue agent, triggered weekly to pull and analyze stock data from Google Sheets. This workflow involves fetching detailed information, structuring financial data, and utilizing specialized agents for in-depth analysis.

The workflow continues by filtering and selecting top candidates, fetching detailed pages, and extracting relevant data using CSS selectors. Specialized agents, such as the financial analyst agent on DeepSeek, provide fundamental analysis using structured inputs and clear contracts. The agent's output includes a comprehensive JSON object with key financial metrics, analysis summaries, and confidence scores. By defining strict contracts, the model operates like a functional analyst, ensuring data consistency and quality.

This structured approach enhances the analysis process, focusing on deliberate multi-step reasoning over raw data to generate insightful reports. The deployment of specialized agents with specific functions streamlines the analysis workflow and ensures consistent output quality. By standardizing the analysis process with defined fields and structured JSON outputs, the workflow promotes reliability, accuracy, and thorough examination of key financial indicators.

It selects, for example, the top 5 candidates to analyze. For each stock, it uses the HTTP request nodes to fetch detailed pages from a site like Screener. To avoid rate limits and lockouts, requests are batched with concurrency and delays so we never hammer the endpoint. HTML is passed into N8n's HTML extract node, which uses CSS selectors to extract the tables we care about. Market cap, valuation ratios, quarterly earnings, cash flows, shareholding patterns, into structured JSON.

At this point, we have structured financial data and technical indicators for each candidate ready to be analyzed. Instead of asking one do-everything model to go from raw HTML to final email, we compose specialized agents with clear contracts. The first specialist is a financial analyst agent running on DeepSeek because deliberate, multi-step reasoning over structured inputs is exactly what you want for fundamental analysis. It is deployed locally via Olama. In practice, we run DeepSeek in its think or deliberate mode for this step, encouraging it to reason through the tables instead of jumping to shortcuts.

We pass in the script JSON, market cap, PE, earnings trends, cash flows, ownership structure, plus the technical signals from the sheet. The system prompt is a pipeline contract. In effect, you are a fundamental equity analyst. Input structured JSON with defined fields. Output a JSON object with a strict schema. Tickle, thesis summary, key risks, valuation view, profitability, cash flow quality, governance nodes, and confidence score between 0 to 10. Do not invent tickers or numbers. If data is missing, mark it as unknown and explain why.

That contract constrains the model to behave like a function. Input JSON, output JSON. It also reduces hallucination by explicitly tying it to the scraped input. The ticker always comes from the sheet, so making up a symbol simply isn't an option. Optionally, a small news agent can run alongside it. Given the ticker and company name it receives, recent news compresses it and feeds a short summary into an extra field in the same schema.

Everything else stays tabular. The second specialist is a web designer agent using QuenCoder model because it consistently produces structured well-formed code under constraints, which is exactly what an HTML email generator needs. We feed it to the analyst JSON with a different contract. You are a front-end engineer generating HTML for email. Input analyst reports, which is an array of JSON objects with defined keys. Output a single HTML string with inline CSS compatible with common email plans, no scripts, and no external CSS.

Requirements are to preserve all numerical fields exactly. For each stock, render a summary card with name, ticker, thesis summary, and a compact metrics table. Encode confidence visually with colors or icons for risk levels. Produce HTML only, no markdown, no commentary. The architecture now looks like this. The first step is our collaboration plane. This is where our strategy lies. The second step is a scraper used for deterministic data acquisition. The third step is the deep-seek financial analyst. Fourth step is the QuenCoder web designer used for presentation. And the last step is the email sender used for delivery. This is not one big intelligence. It's a pipeline of specialized well-typed functions.

What happens when things fail? The workflow is idempotent and restartable. Each stock is processed independently. Intermediate artifacts, script.json, analyst.json, HTML snippets are persisted as items in N8n. If one HTTP request times out or one LLM call errors, we just rerun that node for that stock. Rerunning the whole Monday job with the same sheet yields the same email, not three duplicates. We treat human in the loop as a feature, not a patch.

Before the emails go out, the workflow pauses on a review node. I can inspect the analyst.json for each stock and the composed HTML email. This design aligns with robust agent frameworks which emphasize persistent state and checkpointing, so stateful agents can pause for human feedback and then continue from the same state, recover from errors, and resume without losing context. Two other details you can additionally apply are batching and backoff on HTTP requests using N8n's looping and delay features to avoid rate limits and keep the pipeline robust. CSS selector hygiene.

In the HTML extract node, targeting stable attributes and centralizing sectors so when the site layout changes, we update one mapping rather than rewrite the whole flow. The end result? Every Monday on a single machine, a Dockerized N8n instance talks to the local Deep C and Quen models via Olam, processes the sheet, and sends a structured HTML memo. Now let's bring back the pattern to where we started, the narrative collaboration plane. We already have a sheet where each row is a dialog line or node. Columns for dialog ID, branching, multilingual text, encodings, audio references, and UI hints.

Columns for dialog ID, branching, multilingual text, encodings, audio references, and UI hints. Right now, the glue-potion pattern is writers and translators update the sheet, then ping a developer to export, validate, encode, and deploy. The blueprint to fix it is simple. Add a ready-for-staging checkbox or status column that is watched by, some of you might be thinking, we should use AI here as well, but instead, we will use automation.

The first step is that checkbox trigger calls a webhook that runs the automation. When ready-for-staging flips to true for a given build or a content batch, it fetches all the relevant rows, runs a validation script to check for missing dialog IDs, broken branches, missing localizations, or missing audio files. It applies the encoding transformations for languages like Hindi and Thai, where engines expect specific fonts or glyph adjustments. The commits are updated to GitHub, and it triggers a GitHub actions pipeline to build and deploy to staging.

Most of this doesn't require AI at all. It is deterministic, testable automation. Where AI does help is understanding. A narrative QA agent can scan text to flag inconsistent speaker names, missing variable, or tone issues across languages. A style agent can suggest tightening verbose lines, or flag culturally awkward references for specific locales. The deployment decision stays human. A writer or a producer checks the box. The system does the rest. The key point is, use simple automation for moving and transforming data. Use AI agents when you genuinely need understanding, reasoning, or regeneration.

The collaboration plane is wherever humans already encode intent. The AI glue agent is the layer that reliably turns that intent into action. As engineers and technical leaders, we've automated infrastructure and deployment, but orchestration remains under-automated. It offers control over data privacy, cost predictability, and strategic capability.

Major platforms are moving towards shareable AI agents for workflow automation. The shift is towards intelligent orchestration systems where agents can understand, reason, and adapt within defined guardrails. Architects need to focus on defining intent rather than executing every step. Insert AI glue agents where understanding and reasoning are essential.

Identify collaboration planes and glue people to integrate AI glue agents effectively. Design clear schemas and workflows for idempotent, supervised graphs that allow for human input. Transform AI from a superficial addition to the core glue, ensuring reliability, observability, and control. Transition from being the glue to being the architect in charge.