Tutorials
Practical, step-by-step guides for putting Auxot to work — from saying hello to your first agent through running gap-finding automations on your business plans.
Lessons are grouped by theme below — nothing here assumes a big IT team. Use search or audience filters anytime.
Say hello to the Admin Agent
Send your first message to the Admin Agent, your built-in teammate, whose job is helping you build the agents your business actually needs.
Generate your first API key
Create an API key and use it to plug Auxot agents into the apps you already use: Zapier, Cursor, your scripts, anywhere.
Take Auxot's pulse in 10 seconds
Open System Health and learn to read the dashboard at a glance — your daily ten-second confirmation that everything's running smoothly.
Add your first context file
Paste a chunk of your business — brand voice, sales playbook, or meeting minutes — into a context file, attach it to your agent, and watch the next reply change shape.
Give your agent its job description
Give an agent a clear Description and the right context files, and watch its answers tighten up to match the role you want it to fill.
Invite your first teammate
Send your first invite, pick the right role, and bring a teammate into a setup that already knows your business.
Create an agent from scratch
Build your first custom agent — a specialized teammate for one specific kind of work — by chatting through it with the Admin Agent.
Define a tool policy
Give your agents real-world capabilities — web search, GitHub access, Slack messaging, anything — by bundling tools into a reusable tool policy and attaching it to whichever agents should have it.
Connect a cloud AI model
Plug a cloud AI provider — OpenAI, Anthropic, or both — into your Auxot account so your agents have an AI model to actually generate responses.
Connect a GPU worker
Run AI on your own hardware — connect a local GPU to Auxot so your agents think on a machine you control, with no data leaving your building.
Create a shared Team API Key
Generate an API key that belongs to a team instead of a person — so your CI pipeline, your cron jobs, and your webhook handlers don't break the day someone leaves.
View your audit logs
Open the Audit Logs page to see every job that's run, every conversation that's happened, and every system event — in one searchable, live-updating view.
Run a workflow
Chain prompts, agents, and humans into ordered steps so repeat work always follows the same path — and watch each task move through the steps on a kanban board.
Build your first Dashboard
Pin the answers that matter — sales totals, daily metrics, and weekly summaries — to one page you can check at a glance, with each answer drafted by the agent best suited to write it.
Set up an Escalation
Teach your agents when to stop and ask for a human — and watch the Escalations page so you're the one they call when it matters.
Connect Slack to your agents
Wire your agents into Slack — so the AI you've built lives inside the channels your team is already in, recognizing each person and replying where conversations actually happen.
Manage your Credentials
Store API keys, OAuth tokens, and external-service secrets in one place — encrypted, scoped to who needs them, and ready for your agents and integrations to use without ever seeing the raw values.
Add an MCP server
Connect an MCP (Model Context Protocol) server to a tool policy and give your agents access to a new set of tools — GitHub, Slack, Notion, or your own internal APIs.
Create a Skill
Bundle a reusable instruction pattern — a way you want an agent to handle a specific kind of work — and attach it to one or more agents.
Set up multi-team isolation
On Business tier and above, split your organization into teams that each have their own agents, credentials, context files, and tool policies — each team's resources stay inside that team, with the license, AI providers, and audit logs shared above the team boundary.
Customize your Profile
Update your name and email, change your password, manage where you're signed in, and pick a theme — the things that make Auxot feel like your account.
View and manage your License
Install your commercial license key, see what tier you're on, and understand what each tier unlocks for your team.
Connect a CLI provider (Claude Code, Cursor, Codex)
Wire your CLI tool of choice — Claude Code, Cursor, or OpenAI Codex CLI — to use Auxot as its AI backend, so terminal sessions go through your governance, your context files, and your routing.
Finish first-run onboarding
Clear Auxot’s welcome wizard at **`/app/onboarding`**: GPU demo key, agents, chat, audit logs, and billing. Finish so your org leaves **registration** state and teammates stop landing on **onboarding-blocked**.
Link your chat apps to your Auxot account
Finish **Settings → Linked Accounts** once so Slack and Discord bots know which Auxot user you are, tools stay scoped correctly, and mentions in channels stop coming back as a 🙈 reaction.
Connect Discord to your agents
Wire your agents into Discord — same teammates, same agents, verified identity — so answers land in the servers and threads where your community already talks.
Pick personal or team API keys for real work
Match `user.` keys to laptops and prototypes — `team.` keys to CI, intakes, and anything teammates panic-debug at 2am — without memorizing philosophy.
Unstick your first week in Auxot
Name the five dead-ends new people actually hit (empty chat, blocked app, silent Slack, red System Health, wrong API key shape) so you know which tutorial to open instead of thrashing.
Find the right screen for your next question
Open each primary destination once, learn what kind of work belongs in **Chat** versus **System Health** versus **Context Files**, **Workflows**, and **Settings**, and stop opening the wrong drawer when you have a question.
Make your first hour in Auxot count
Run one ordered pass through **System Health**, **Chat**, provider reality for admins, a tiny **Context Files** win, and a five-second **Audit Logs** peek so your first hour has checkpoints instead of aimless clicking.
Verify your org is ready before you invite
Run a short owner checklist so the first human you invite lands in **Chat** instead of **onboarding-blocked**, hits a working model route, and has tutorial links beside the invite link when Auxot does not auto-email.
Choose your day-two track in Auxot
Stop reopening every menu on day two. Pick one track (context, workflow, Slack, or a specialist agent), finish a single **Quick start** through its **Done?** line, and defer the other tracks on purpose for the rest of the week.
Know what the Escalations bell is for
Open **Escalations** once, learn what a paused agent is asking you for, and tell the difference between a human-waiting card, a generic error, and a red **System Health** tile before you blame the model.
Know when Workflows beat a long Chat thread
Contrast **Chat** with **Workflows** once: same shape of work, repeat gates, humans in the middle, and starters from outside Auxot belong on a board, not in a single endless thread.
Understand Credentials, OAuth, and API keys in Auxot
Open **Settings → API Keys**, **Settings → Credentials**, and **Settings → OAuth** once each, learn which direction each secret travels (into Auxot versus out to vendors), and stop pasting the wrong kind of key into the wrong box.
Run an agent on a schedule
Give one of your agents a cron clock — the prompt you wrote fires on the schedule you chose, with optional Discord delivery — so recurring reports and checks stop living on sticky notes.
Trigger a workflow with an intake webhook
POST JSON from GitHub Actions, your backend, or a cron job — get a work_id back on the spot, poll until the workflow finishes, and wire the same pattern anywhere HTTP leaves off.
Trace a failing job end to end
Start from the symptom — stuck workflow, Slack silence, a red Jobs row — and walk backward through Threads, Jobs, and Events until you know whether routing, tools, or credentials broke.
Read provider routing like an operator
Learn Auxot's GPU → CLI → cloud cascade, heartbeat timeouts, and invisible failover — so latency spikes, surprise cloud bills, and gray worker dots tell a story instead of feeling random.
Connect OAuth for MCP tools
Wire **Settings → Connected Accounts** so tool policies that use **`oauth`** sources resolve **your** GitHub (or other provider) token — per-user MCP calls instead of one shared PAT sitting unused in a static field.
Back up and export your Auxot data
Build an honest runbook for your Auxot data and config — database backups for self-hosted installs, **Audit Logs** via API when the UI has no CSV button, and manual artifact copies (context files, directories, and instruction exports) — without pretending one button ships your whole org to a zip file.
Harden your intake webhooks
Treat intake URLs like production ingress — team-scoped keys, careful secret handling, idempotent payloads, and callback caution — so automation can't ransom workflows or leak Bearer tokens into logs.
Accept your invitation and join your organization
Use the invite link your admin sent, set a strong password on **Accept Invitation**, sign in, and know what to do if the org is still finishing first-run onboarding.
Onboard a new teammate to your agents
Run a 30-minute onboarding session that introduces a new human hire to the agents already on your team: what each one does, when to use it, and how to build their own.
Set up your Monday morning briefing
Build a recurring briefing that lands wherever you read your morning notifications — what happened last week, what to worry about this week, and what should already be on your calendar.
Build your customer support agents
Build three agents that work together to triage, draft, and escalate customer support — so tickets get answered fast and the hard ones land on the right person.
Set up a content review pipeline
Build a pipeline where an agent drafts content, a human reviews it, and only approved drafts go out — so you get the speed of agent drafting without the risk of unedited drafts.
Triage and follow up on inbound leads
Build an agent that reads new sales leads the moment they come in, scores them by fit and timing, drafts a personalized first response, and surfaces who needs a follow-up — so leads stop sitting cold.
Review documents against your standard terms
Build an agent that reads incoming contracts, RFPs, or vendor agreements, compares them against your standard terms, and flags every deviation by risk — so your reviewer reads the flags, not the whole document.
Build an internal Q&A agent for your team
Build an agent that answers your team's internal questions — policies, processes, 'where's the X file' — by reading your handbook and SOPs, so the same five questions stop landing on the same one person.
Turn meeting notes into action items and decisions
Build an agent that reads raw meeting notes or a transcript and produces a clean breakdown — decisions made, action items by owner, unresolved questions — so nothing falls through the cracks between meeting and execution.
Screen resumes and draft replies
Build an agent that reads inbound resumes against your job description, scores fit on hard and soft signals, flags standouts, and drafts the response — so the right candidates get to a human conversation faster.
Prep for your next sales call
Build an agent that reads who you're meeting, what they probably care about, and what's already happened with the account — then produces a one-page brief with talking points and likely objections, in under sixty seconds.
Build your bug-report triage agents
Build three agents that work together to triage incoming bug reports — score severity, dedupe against known issues, chase down missing repro info, and route to the right team — so engineers stop spending Monday morning sorting tickets.
Replace an agent currently in use
Stand up a Replacement Plan agent that turns an agent your team relies on into a clean handoff to a successor — who to use instead, until when, and what to detach — so bookmarks and muscle memory do not send people into a wall.
Call the Anthropic-compatible Messages API
Point Claude Code, the Anthropic SDK, or plain curl at Auxot's Messages endpoint — same headers and JSON Anthropic clients expect, with routing through your providers when you pass model auto.
Run the open-source inference router
Spin up auxot-router — single Go binary, OpenAI- and Anthropic-shaped APIs — attach auxot-worker for GPU or CLI inference, and curl your first completion without Postgres or agent accounts.
Route Cursor and Claude Code through Auxot
Put your editor and terminal on the same routing spine — Cursor via OpenAI-compatible base URL, Claude Code via Anthropic Messages — so local or LAN Auxot picks GPU, CLI, or cloud per your provider order.
Call the OpenAI-compatible Chat Completions API
Point curl, GitHub Actions, or the OpenAI Python SDK at Auxot's Chat Completions endpoint — same JSON OpenAI clients expect — with `model: "auto"` riding your GPU → CLI → cloud order.
Self-host Auxot stage by stage
Move from the official Docker Compose bring-up through production-shaped choices — managed Postgres and Redis, pinned images, TLS, and systemd or Kubernetes — without pretending air-gapped labs are the same job as a single laptop experiment.
Trigger a workflow from GitHub Actions
Drop a **`workflow_dispatch`** job into `.github/workflows/` — POST your intake with repo secrets, capture **`work_id`**, poll until **`completed`** or **`failed`** — same contract as [Trigger a workflow with an intake webhook](/tutorials/trigger-a-workflow-with-an-intake-webhook) but with **`GITHUB_RUN_ID`** correlation baked in.
Catch regressions after you change an agent
Freeze a **mini regression pack** — a handful of prompts plus plain-English pass rules — and rerun it whenever job descriptions, models, providers, or tool policies shift, so regressions show up as failed checks instead of silent weirdness in prod chat.
Batch spreadsheet rows through a workflow
Turn a CSV or sheet export into **one workflow design**, stable **correlation IDs** per row, and either **intake loops** ([Trigger a workflow with an intake webhook](/tutorials/trigger-a-workflow-with-an-intake-webhook)) or disciplined **New task** batches — with sampling for QC and Audit Logs search-friendly payloads.
Plan for retention and deletion requests
When legal, HR, or a customer asks *what you keep in Auxot and how to wind it down* — map **threads, jobs, events, and configs** to **real actions** (access off, keys revoked, and org membership removed) — honest about **audit history growth** and **backup overlap**, not a fantasy one-click erase.
Red-team your agents against prompt injection
After honest stress-testing ([Stress-test an agent before you widen access](/tutorials/stress-test-an-agent-before-you-widen-access)), run a **red-team session** — instruction-injection wording, asks shaped like **leaking internal data**, and fake authority — log outcomes in **Audit Logs**, tighten **tool policies** and **approval gates**, and know when to escalate beyond chat-based red-teaming.
Answer vendor security questionnaires from your own evidence
Turn scattered truth (**context files**, the **manual**, **Audit Logs** behavior, and backup runbooks) into **draft questionnaire rows** about **your** Auxot usage so security review has somewhere to start, without letting chat **invent** certifications you do not hold.
Allocate model spend to teams for internal reporting
Turn **Jobs** token rows ([View your audit logs](/tutorials/view-your-audit-logs)) into a **finance-friendly allocation** — map work to **teams** using agents, keys, and naming discipline — so departmental visibility spreadsheets defend budgets without pretending Auxot replaces formal accounting.
Route intent to the right specialist agent
Stand up a **router agent** that reads the user’s first turn, classifies **intent** in one pass, answers only what fits a tight job description, then **names one specialist** and hands off a tight paste block. Coworkers stop opening the wrong agent and smuggling everything into a mega-prompt.
Build an audit narrative from your logs
Turn **Audit Logs** (Jobs, Threads, and Events) into a **story auditors and customers can follow**: who acts, what changed, and how failures surface. Built from filters and exports ([Create a shared Team API Key](/tutorials/create-a-team-api-key), [Back up and export your Auxot data](/tutorials/back-up-and-export-your-auxot-data)), not a pile of screenshots and not invented certifications.
Use two-person rules for high-impact actions
When **one approver is not enough**, separate **who proposes** from **who commits** on destructive or money-moving tools using **split agents**, **narrow tool policies**, and **workflow human steps** ([Run a workflow](/tutorials/run-a-workflow), [Require human approval before risky actions](/tutorials/require-human-approval-before-risky-actions)) so governance sticks without freezing everyday work.
Run scheduled canary checks on production agents
Reuse your frozen prompts ([Catch regressions after you change an agent](/tutorials/catch-regressions-after-you-change-an-agent)) on a **calendar**, not only after edits — **cron-fired probe chats** ([Run an agent on a schedule](/tutorials/run-an-agent-on-a-schedule)) plus tight **pass-shaped output** so provider changes, silent instruction tweaks, or tool breakage surface in **Discord** or **Jobs** before customers carry the news.
Triage pull requests before humans review them
Stand up a **PR triage agent** — classify risk, flag missing tests or docs, and surface security-sensitive diffs — so reviewers open the scary merges first — optional **GitHub MCP** ([Add an MCP server](/tutorials/add-an-mcp-server)) for read-only metadata; paste mode still works when you cannot wire tools yet.
Turn incident lessons into updated runbooks
After the post-mortem doc ships ([Run a post-mortem that leads to action](/tutorials/run-a-post-mortem-that-leads-to-action)) — **promote follow-ups into Auxot** — context-file paragraphs, agent instruction patches, workflow checklist rows, and new regression prompts ([Catch regressions after you change an agent](/tutorials/catch-regressions-after-you-change-an-agent)) — so *what we learned* lives where operators actually work, not only in a PDF.
Turn account research into CRM field updates
Stand up a **CRM Mapping** agent — ingest notes, call summaries, or read-only CRM context — output **proposed field values** (next step, pain, stage hint, and competitor mentions) in a paste-friendly shape — **you** apply or approve writes — optional MCP ([Add an MCP server](/tutorials/add-an-mcp-server)) stays narrow.
Stress-test your pitch with simulated buyer personas
Stand up a **pitch-rehearsal agent** — rotate skeptical CFO, security lead, and end-user voices against **your** demo narrative — surface objections and trap questions **before** real prospects invent them — grounded in ideal-customer-profile context ([Add your first context file](/tutorials/add-your-first-context-file)) — debrief stays human.
Run a deal desk for pricing and legal exceptions
Stand up a **deal-desk intake agent** — intake messy exception asks (discount depth, payment timing, and non-standard paper) — output a **single approver packet**: facts, policy cites, risk flags, and draft decision memo — routed through **human steps** ([Run a workflow](/tutorials/run-a-workflow), [Require human approval before risky actions](/tutorials/require-human-approval-before-risky-actions)) — not autonomous discounts or legal sign-off.
Roll up initiative threads into weekly goal check-ins
Stand up a **goal-rollup agent** that takes a week's worth of Slack threads, doc comments, or PM bullets and emits **initiative → confidence → blockers → exec ask**. Separate from the Monday morning briefing ([Set up your Monday morning briefing](/tutorials/set-up-your-monday-morning-briefing)) and from single-meeting synthesis ([Turn meeting notes into action items and decisions](/tutorials/turn-meeting-notes-into-action-items)).
Turn internal office hours into FAQ updates
Stand up an **office-hours harvest agent** that takes raw questions from a live session, a Slack thread, or meeting notes and emits **normalized FAQ rows + draft handbook language + gap flags**. Merge only after human review so your internal Q&A agent ([Build an internal Q&A agent for your team](/tutorials/build-an-internal-q-and-a-agent)) cites fresher truth.
Adapt copy with human review
Stand up an **Adaptation** agent. Paste source copy plus your glossary and tone rules. Emit **adapted draft + terminology receipts + risk flags**. Route every publish path through the same human-review habit as marketing pipelines ([Set up a content review pipeline](/tutorials/set-up-a-content-review-pipeline)). No invisible multilingual autopilot.
Catch drafts that break your writing rules
Stand up a **Style check** agent. Paste outbound draft. Compare against your glossary and banned-phrases context. Emit **violations table + severity + fix hints**. Run **before** approval steps ([Set up a content review pipeline](/tutorials/set-up-a-content-review-pipeline)) so reviewers argue substance, not hyphen wars.
Automate weekly checkups on your agents
Stand up a **weekly-checkup agent** and wire it to **Scheduled Tasks** ([Run an agent on a schedule](/tutorials/run-an-agent-on-a-schedule)). Each run emits the same **weekly checklist** for agents, context, credentials, workflows, and replacement candidates, so rot surfaces on the calendar instead of during an incident.
Save quality rubrics for your agents
Stand up a **rubric scoring agent**. Freeze saved prompts plus expected-shape rules and scored rubric dimensions. Rerun after a model swap or instruction change. Regressions show up as scores and missed criteria, not as a feeling that something is off. Extends binary regression packs ([Catch regressions after you change an agent](/tutorials/catch-regressions-after-you-change-an-agent)) without extra tooling.
Fix when requests go to the wrong agent
Stand up a **Routing Tune-up Agent**. Paste real first messages where the Router picked the wrong specialist (or answered instead of routing). Emit **confusion matrix + instruction patches + handoff discipline**. Iterate **after** your Router exists ([Route intent to the right specialist agent](/tutorials/route-intent-to-the-right-specialist-agent)), not another mega-prompt overnight.
Connect two business tools
Stand up an **Integration Map Agent**. Name **system A → event**, **system B → action**, and **Auxot in the middle**. Use workflows ([Run a workflow](/tutorials/run-a-workflow)), intakes ([Trigger a workflow with an intake webhook](/tutorials/trigger-a-workflow-with-an-intake-webhook)), and MCP tools ([Add an MCP server](/tutorials/add-an-mcp-server)), plus explicit **human gates** when writes touch money or customer records. Integrations should read like architecture, not folklore.
Audit and clean up your agents
Build an Agent Audit that reviews your custom agents, surfaces overlap and decay, and tells you exactly what to delete, consolidate, or sharpen — then run it monthly.
Enable tool calls with auxot-tools
Stand up the third Auxot binary (`auxot-tools`) so completions can execute tool calls: built-ins (fetch, search, code), MCP servers, and optional shell tools. Wire it to **either** the OSS router (`AUXOT_TOOLS_KEY` + router hash) **or** Auxot Server (a `tools.{id}.{secret}` connector key that downloads the full policy on connect).
Track commitments across meetings
Pair meeting minutes with a living **commitments ledger** context file so an agent flags **said-we'd-do** lines that vanish across weeks. Owners, stall reads, and next steps **you** own, grounded in quoted text so nothing is invented.
Check System Health in five minutes
Use **System Health** on purpose: same five-minute pass admins reuse before a stand-up or after someone says things feel slow. Gray dots and quota bars tell a story instead of eating your afternoon.
Poll an intake job until it finishes
Treat **`202 Accepted`** as a queue ticket: capture **`work_id`**, loop **`GET /v1/intake/{INTAKE_ID}/work/{WORK_ID}`** until **`completed`** or **`failed`**, from a shell script or CI job, without pretending the first POST already ran the workflow.
Wire your first tool with least privilege
Walk one first-week path: store outbound secrets in **Settings → Credentials**, assemble the smallest **tool policy** (**Settings → Tool Connector Keys** / tool policies), and attach it to a single agent so optional tools stay optional.
Run a quarterly initiative audit from scattered notes
Stand up an **Initiative Audit Agent**. Paste scattered planning notes, thread exports, and meeting summaries. Classify each effort as **Pursued**, **Thin**, or **Absent**. End with an explicit **not doing** list that leadership can defend.
Audit your tools and vendors
Stand up a **Vendor Inventory** agent. Paste finance exports, shadow IT lists, or **what we use** threads. Surface **overlap**, **forgotten subscriptions**, and **unknown owners**. End with one **Deactivate** candidate set and a 30-minute dedupe decision you can calendar.
Build handoff templates between teams
Stand up a **Handoff Miss** agent. Paste redacted cross-team threads. Classify failure **archetypes** (missing field, wrong owner, slip, tone). Emit paste-ready **template blocks** for Slack, email, and tickets so the next handoff lands clean.
Track strategic decisions and when to revisit them
Stand up a **Decision Log** agent. Keep your strategy one-pager and **ideas we discussed this half** in context. Paste new fragments as they appear. Emit rows for **Idea**, **why it looked attractive**, **reason set aside**, and **revisit trigger**. Rerun quarterly and diff only what changed.
Recover forgotten meeting commitments with owners and drafts you send
Mine recent meeting minutes for **said-once, never-seen-again** commitments, lock each row to a **named owner** and a **next human step**, and generate **calm nudge drafts you paste yourself** so follow-through stays fast without surprise pings.
Tag metrics that drive decisions
Give the Admin Agent a **classification rubric** and your metric inventory so it tags **vanity** (moves without forcing a decision) vs **decision** (moves budget, scope, or calendar). Export a one-page **exec decision-metric list** plus a separate **orientation** list for charts that stay visible but don't drive spend.
Map your subprocessors for procurement
Turn Settings → Providers, MCP servers, and Credentials into a vendor-by-vendor list procurement teams already understand, with data categories, region, and DPA status per row, so your security questionnaire does not ship with *we'll get back to you* next to the subprocessor question.
Build a SOC 2 control mapping for your Auxot deployment
Map each SOC 2 Trust Service Criteria control to the Auxot page, audit-log filter, or context file that satisfies it, so when the auditor opens your spreadsheet, every row points to evidence they can verify in under a minute, not a meeting your team has to schedule.
Write the agent section of your customer-facing security page
Most company `/security` or `/trust` pages either overstate (*enterprise-grade AI security*) or punt (*contact us for details*); both lose deals. Draft the agent subsection from honest evidence: subprocessors named, data-flow described, retention spelled out, gaps acknowledged, using the same inventory your sales team cites in vendor questionnaires.
Run an incident tabletop exercise
Rehearse an agent incident before you have one. Pick a realistic scenario (agent leaked data into the wrong team, a tool fired when it should not have, a prompt-injection attempt got past your defenses) and walk the team through detection, containment, comms, and post-incident review so the real one does not become the first time anyone tried.
Document your agent usage for cyber insurance renewal
Cyber insurance carriers ask agent-exposure questions at every renewal now, and answering too little raises premiums while answering too much ships claims you cannot defend. Build a renewal packet from the same Auxot evidence your sales team already uses for procurement: model providers in scope, data categories, controls in place, retention specifics, incident history.
Bundle a customer trust packet from your audit evidence
Stitch the artifacts you already built (**audit narrative** ([Build an audit narrative from your logs](/tutorials/build-an-audit-narrative-from-your-logs)), **subprocessor inventory** ([Map your subprocessors for procurement](/tutorials/map-your-subprocessors-for-procurement)), **SOC 2 control map** ([Build a SOC 2 control mapping for your Auxot deployment](/tutorials/build-a-soc-2-control-mapping-for-your-auxot-deployment)), **retention stance** ([Plan for retention and deletion requests](/tutorials/plan-for-retention-and-deletion-requests)), and **two-person rules evidence** ([Use two-person rules for high-impact actions](/tutorials/use-two-person-rules-for-high-impact-actions))) into one **dated, redacted, audience-aware bundle** enterprise procurement can review without scheduling another call.
Track which audit fields each questionnaire asks about
Every completed vendor security questionnaire ([Answer vendor security questionnaires from your own evidence](/tutorials/answer-vendor-security-questionnaires-from-your-own-evidence)) is also a **signal about what buyers care about** — tag each one with which Auxot surfaces and audit-log fields it actually touched, roll the tags up over time, and let the resulting **frequency table** reorder your next audit narrative ([Build an audit narrative from your logs](/tutorials/build-an-audit-narrative-from-your-logs)) and trust packet ([Bundle a customer trust packet from your audit evidence](/tutorials/bundle-a-customer-trust-packet-from-your-audit-evidence)) so the hottest fields land first.
Walk your auditor through the logs in 30 minutes
Run a structured **live walkthrough** of **Audit Logs** ([View your audit logs](/tutorials/view-your-audit-logs)) for an auditor or enterprise security reviewer: three tabs (Jobs, Threads, Events), a rehearsed filter sequence per tab, a talk-track that fits inside 30 minutes, and Admin-Agent help mid-meeting when the reviewer asks for something you didn't pre-stage.
Hand off the audit narrative when your compliance lead changes
When your compliance lead leaves, gets promoted, or your function reorgs, the four procurement-lane artifacts (audit narrative, trust packet, frequency table, SOC 2 mapping) need to survive the transition. Build a structured handoff that keeps the next renewal from becoming archaeology.
Run an internal pre-audit drill against your own narrative
Run a 30-minute internal exercise where one teammate plays auditor and another defends the audit narrative under live questioning. Surfaces gaps before the real audit window opens, doubles as a new-compliance-lead onboarding test, and produces a dated fix list.
Use a DRAFT_ tab for agent spreadsheet writes
Wire any spreadsheet-write workflow so the agent writes to a `DRAFT_summary` tab instead of the live tab. The live tab stays canonical; the DRAFT_ tab is the structural review gate. Foundational pattern referenced by batch workflows, questionnaire logs, and any future spreadsheet writeback.
Lock CRM writes to a single custom field
Wire any CRM-write workflow so the agent reads everything it needs but writes only to one custom field like `auxot_research_summary`. Never deal stage, never close date, never amount. Foundational pattern referenced by account research, deal desks, and any future CRM tutorial.
Wire Gmail drafts through Google's official MCP
Connect Google's official Gmail MCP so any agent that produces email content lands the result in Gmail Drafts, not in the recipient's inbox. The Drafts folder is the structural review gate. Free MCP, draft-only by design, no separate Auxot review step needed.
Lock Outlook drafts via a draft-only tool policy
Wire Composio Outlook so any agent that produces email content lands the result in Outlook Drafts, never in the recipient's inbox. Microsoft does not offer a first-party Outlook mailbox MCP as of May 2026; Composio Outlook is the recommended path, locked down to draft tools via the Auxot tool policy.
Keep send_email out of your agent tool policies
The structural argument for draft-only email pipelines: every viable MCP path supports a draft-only tool policy, so the agent's tool policy should explicitly exclude send tools. The human-from-Drafts-folder loop becomes structurally enforced, not policy-on-paper. Principle post applicable to any Auxot agent that produces email content.
Wire social posts through Buffer
Route every agent-drafted social post through Buffer's scheduled-post queue. Buffer's queue IS the human review gate; do not add a second Auxot human-step. Covers Buffer's official MCP, why direct LinkedIn and X are not viable in May 2026, and Bluesky as the one direct-platform exception worth wiring.
Use the hold-first pattern for agent calendar events
Wire any agent that touches a calendar so it creates host-only HOLD events instead of real invites with attendees. The human promotes the HOLD to a real invite when ready. Calendar attendees never get an agent-generated invite they did not expect. Foundational pattern for any future calendar-related Auxot workflow.