> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getthread.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Automation Engineer

> The automation engineer's course for Thread: build Flows, Intents, Super Magic skills, and drive Thread over MCP, API, and webhooks — plus a starter kit.

export const ByRoleProgress = () => {
  useEffect(() => {
    const KEY = "thread-onboarding-completed";
    const TEAL = "#00B398";
    const BASE = "/start-here/roles/";
    const DONE_ICON = '<svg class="thread-rc-doneicon size-4" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="#00B398" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">' + '<path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/>' + '<polyline points="22 4 12 14.01 9 11.01"/></svg>';
    const COURSES = [{
      slug: "technician",
      steps: ["why-thread", "get-around-inbox", "day-one-setup", "daily-workflows", "ai-toolkit", "notifications-and-customers"]
    }, {
      slug: "dispatcher",
      steps: ["why-dispatch-in-thread", "read-the-board", "assign-and-schedule", "ai-for-dispatch"]
    }, {
      slug: "service-ops-manager",
      steps: ["set-up-the-desk", "sla-and-dispatch", "analytics-and-qa", "roll-out-and-adopt"]
    }, {
      slug: "csm-account-manager",
      steps: ["client-intelligence-and-health", "qbrs-and-reporting", "retention-and-expansion"]
    }, {
      slug: "security-compliance-owner",
      steps: ["security-work-in-thread", "data-and-compliance", "security-runbooks"]
    }, {
      slug: "sales-business-development",
      steps: ["the-ai-service-pitch", "quote-and-handoff"]
    }, {
      slug: "msp-owner-leadership",
      steps: ["the-rollout", "outcomes-and-analytics", "scale-ai-service"]
    }, {
      slug: "automation-engineer",
      steps: ["flows-and-intents", "thread-mcp-and-api", "build-with-super-magic"]
    }];
    const COURSE_SLUGS = new Set(COURSES.map(c => c.slug));
    const readLocal = () => {
      try {
        return JSON.parse(localStorage.getItem(KEY) || "[]");
      } catch (e) {
        return [];
      }
    };
    const isDone = (done, id) => done.includes(id);
    const decorate = () => {
      const done = readLocal();
      const scope = document.getElementById("sidebar-content") || document;
      const links = [...scope.querySelectorAll('a[href*="' + BASE + '"]')].filter(a => !a.closest("main"));
      links.forEach(a => {
        const m = (a.getAttribute("href") || "").match(/\/start-here\/roles\/([^/?#]+)\/([^/?#]+)/);
        if (!m) return;
        if (!COURSE_SLUGS.has(m[1])) return;
        const id = m[1] + "/" + m[2];
        const d = isDone(done, id);
        const has = a.querySelector(".thread-rc-check");
        if (d && !has) {
          const s = document.createElement("span");
          s.className = "thread-rc-check";
          s.textContent = "✓ ";
          s.style.color = TEAL;
          s.style.fontWeight = "700";
          a.insertBefore(s, a.firstChild);
        } else if (!d && has) {
          has.remove();
        }
      });
      COURSES.forEach(course => {
        const li = scope.querySelector('li[id="' + BASE + course.slug + '"]');
        if (!li) return;
        const row = li.querySelector(":scope > button") || li.querySelector(":scope > a") || li.firstElementChild;
        if (!row) return;
        const nameSpan = [...row.querySelectorAll("span")].find(s => s.textContent.trim() && !s.classList.contains("thread-rc-coursecheck"));
        if (!nameSpan) return;
        const allDone = course.steps.length > 0 && course.steps.every(s => isDone(done, course.slug + "/" + s));
        const has = nameSpan.querySelector(".thread-rc-coursecheck");
        if (allDone && !has) {
          const s = document.createElement("span");
          s.className = "thread-rc-coursecheck";
          s.setAttribute("aria-hidden", "true");
          s.style.display = "inline-flex";
          s.style.alignItems = "center";
          s.style.verticalAlign = "-0.2em";
          s.style.marginRight = "0.35em";
          s.innerHTML = DONE_ICON;
          nameSpan.insertBefore(s, nameSpan.firstChild);
        } else if (!allDone && has) {
          has.remove();
        }
      });
    };
    decorate();
    const iv = setInterval(decorate, 600);
    window.addEventListener("thread-onboarding-updated", decorate);
    window.addEventListener("storage", decorate);
    return () => {
      clearInterval(iv);
      window.removeEventListener("thread-onboarding-updated", decorate);
      window.removeEventListener("storage", decorate);
    };
  }, []);
  return null;
};

<ByRoleProgress />

You automate the service desk. Where a technician resolves one ticket, you build the thing that resolves a hundred — a Flow that routes on its own, an Intent the Triage Agent runs unattended, a Super Magic skill your whole team reuses, or a Thread MCP connection that puts the desk inside your own AI client. This is your course: three lessons that take you from in-app automation to code-level control, plus the skills and ritual built for how you work.

Two bits of taxonomy to keep straight as you go: **Thread MCP is part of Super Magic** — the same tool layer, exposed to external clients. And **Super Magic Agents = Super Magic + Flows** — a skill that Super Magic runs, fired automatically by a Flow instead of by a person.

## The course

Work these in order — each ends with a link to the next. Start where your leverage is highest today; most automation engineers begin in Flows and Intents before reaching for the API.

<Steps>
  <Step title="Flows, status automations, and Triage Agent intents">
    Route and update tickets without a human, then teach the Triage Agent what to resolve on its own. [Start here →](/start-here/roles/automation-engineer/flows-and-intents)
  </Step>

  <Step title="Thread MCP, the tool reference, and the API">
    Put the desk inside your own AI client, then drive Thread over webhooks, APIs, and Rewst. [Read →](/start-here/roles/automation-engineer/thread-mcp-and-api)
  </Step>

  <Step title="Build with Super Magic">
    Add external tools with connectors, author reusable Skill Library skills, and ship Automagically runbooks. [Read →](/start-here/roles/automation-engineer/build-with-super-magic)
  </Step>
</Steps>

## Your starter kit

The [Skill Library](/skill-library/overview) has a whole [Automation & Flows](/skill-library/automation-and-flows/overview) category built for your role. Start with these — then press **`⌘K`** and search for any building block ("intent", "flow", "webhook") to find the rest.

<CardGroup cols={2}>
  <Card title="Flow Builder" icon="diagram-project" href="/skill-library/automation-and-flows/flow-builder">
    Design a Flow from a plain-language description of the routing you want.
  </Card>

  <Card title="Intent Builder" icon="robot" href="/skill-library/automation-and-flows/intent-builder">
    Draft a Triage Agent intent — variations, arguments, and replies — from scratch.
  </Card>

  <Card title="Flow Debugger" icon="bug" href="/skill-library/automation-and-flows/flow-debugger">
    Work out why a Flow didn't fire, then fix the condition.
  </Card>

  <Card title="Automation Opportunity Finder" icon="magnifying-glass-chart" href="/skill-library/automation-and-flows/automation-opportunity-finder">
    Mine your ticket history for the repetitive work worth automating next.
  </Card>

  <Card title="Skill Authoring Coach" icon="wand-magic-sparkles" href="/skill-library/automation-and-flows/skill-authoring-coach">
    Turn a working prompt into a clean, reusable Super Magic skill.
  </Card>

  <Card title="Notion Runbook Database" icon="database" href="/skill-library/connectors/notion-client-runbook-database">
    Wire a Notion runbook database into Super Magic through a connector.
  </Card>
</CardGroup>

## Your build ritual

Automation is a loop, not a launch. Run it weekly: **measure, build, verify.**

* **Measure.** Run [Automation Opportunity Finder](/skill-library/automation-and-flows/automation-opportunity-finder) against last week's tickets — where did humans do the same thing more than five times?
* **Build.** Ship the smallest automation that removes it: a status automation, a Flow, an Intent, or a Super Magic skill. One change at a time.
* **Verify.** Watch it for a few days. Use [Flow Debugger](/skill-library/automation-and-flows/flow-debugger) and [Automation Failure Watch](/skill-library/automation-and-flows/automation-failure-watch) to catch anything that fired wrong before your team does.

Build in a sandbox board first when you can, and always leave an internal note on what you changed — Flows re-evaluate on thread updates, so a note is also how you nudge a thread through your new logic.

## Pro tips & FAQ

<AccordionGroup>
  <Accordion title="Flows didn't fire — where do I start?">
    Flows evaluate when a thread is *updated* (reply, note, status change, board change) **after the flow exists**. Add an internal note to nudge a thread through, confirm the condition actually matches, and remember webhooks are near-real-time but not 100% guaranteed. [Flow Debugger](/skill-library/automation-and-flows/flow-debugger) walks the rest.
  </Accordion>

  <Accordion title="When do I reach for an Intent vs. a Flow?">
    A **Flow** routes and updates tickets on defined conditions — no AI judgment. An **Intent** teaches the Triage Agent to *handle a request type* conversationally and resolve it unattended. Rule of thumb: deterministic routing → Flow; "understand and respond to this kind of ask" → Intent.
  </Accordion>

  <Accordion title="What's the difference between a Super Magic skill and a Super Magic Agent?">
    A **skill** is a saved prompt-first workflow a person runs in Super Magic. A **Super Magic Agent** is that same skill fired *automatically by a Flow* — Super Magic + Flows — so the workflow runs with no one in the composer. Author the skill first, prove it by hand, then wire the Flow.
  </Accordion>

  <Accordion title="Why is a tool missing from Super Magic and Thread MCP?">
    Thread MCP exposes the same tool layer as Super Magic, so the same gating applies: write actions are controlled by your admin, intents and flows are admin-only, integration tools appear only once connected, and some connectors (NinjaOne, Linear, Notion, Zapier) need your own sign-in first. See the [Super Magic admin guide](/super-magic/super-magic-admin-guide-setup-access-safety).
  </Accordion>

  <Accordion title="Do I need code to automate Thread?">
    No. Flows, Intents, status automations, and Super Magic skills are all built in-app with no code. Reach for the [API and webhooks](/get-started/webhooks-apis-how-thread-talks-to-your-psa) or [Rewst](/integrations/thread-rewst-integration) only when automation has to reach outside Thread.
  </Accordion>
</AccordionGroup>


## Related topics

- [Build with Super Magic](/start-here/roles/automation-engineer/build-with-super-magic.md)
- [Guides by Role](/start-here/roles/overview.md)
- [Flows, status automations, and Triage Agent intents](/start-here/roles/automation-engineer/flows-and-intents.md)