Documentation

augLab is a no-code platform for building AI agents, teams, and workflows. Pick from 400+ models and 90+ tools and configure everything through the dashboard -- no code required. On the Studio and Team plans, models run on platform-managed keys. On Business and Enterprise, you bring your own provider keys.

What you can build

• Agents -- A single AI assistant with tools. Good for: research, content writing, data analysis, image generation, email management, code execution.
• Teams -- Multiple agents working together. A coordinator assigns tasks to specialists. Good for: complex projects that need different expertise (e.g. a researcher + a writer).
• Workflows -- Step-by-step pipelines. Each step runs an agent or team in sequence. Good for: repeatable processes like content pipelines, data ETL, report generation.

Describe what you want automated in plain English and augLab designs a complete agent, team, or multi-step workflow -- including branches when the job needs them. Nothing is created until you have reviewed the design and clicked Create.

How to use it

1. Open Create with AI. On the Agents, Teams, or Workflows page, click New and choose Describe it (AI). You can also start it from the command palette.
2. Describe the job in up to 4,000 characters. Leave Let AI decide selected, or choose Agent, Team, or Workflow yourself.
3. Review the design. Every agent's name, instructions, model, and tools can be edited, and each model shows why it was picked.
4. Click Create. Everything is created through the normal create steps, so your plan limits and your organization's model and tool policies apply. If any part fails, the agents already created are removed, so nothing half-built is left behind.

Create with AI runs on your organization's AI model and its usage is metered. On Business and Enterprise, add at least one model provider credential first; Studio and Team use platform-managed models.

What a design can include

• Up to 6 agents, and up to 12 steps in any one list of steps.
• Parallel groups, conditions, routers, and loops, nested up to 4 levels deep. Loops run at most 20 times.
• Conditions in a generated workflow are Python expressions. You can switch any of them to a plain-English question in the step inspector.

The New menu

The Agents, Teams, and Workflows pages each have a New menu with three options: Describe it (AI), Blank, and From template.

How AI-built agents are checked

Whenever AI builds an agent -- in Create with AI, the agent wizard, Builder Chat, or the MCP create_agent_from_prompt tool -- the decision engine checks its tools and model against its instructions:

• Adds up to three tools the instructions clearly need but the builder missed.
• Removes a picked tool only when it is near certain the work doesn't need it. File & Code is never removed, because agents create files with it even when the instructions don't mention files.
• Changes the model only when it is two tiers away from the work: a stronger model for complex or expert work, or a cheaper one for simple work that still leaves a tier of headroom.
• Stays within what you can use -- only tools and models you could pick yourself: allowed by your organization or plan, with the account connected, and models from the same provider.

If the decision engine is off, unavailable, or unsure, the builder's choices are kept as they are.

Setup suggestions while you edit

The agent and team forms have a Suggestions panel that checks your setup against your instructions: tools the instructions need, tools they don't, a model that fits the work (agents), and a team mode that fits (teams). Model suggestions only appear when the model is clearly over- or under-powered for the work. For a saved agent with enough run history, it can also point out tools the agent hasn't used in its recent runs.

• It checks when you click Check setup, and a few seconds after you stop editing the instructions.
• After a check, it checks again whenever you change the tools, model, or team mode, so suggestions always match the current setup.
• Apply changes the form only -- you still save as usual. Dismiss hides a suggestion.

An agent is an AI assistant powered by a large language model (LLM) that can use tools to take actions. You configure it once, then interact with it through chat, API, or schedules.

Creating an agent

Go to Agents > Create Agent. The form has these sections:

Try it before you save

The agent form has a preview pane (open by default; click Hide preview to close it). Chat with the agent as it is configured in the form right now -- each message uses your latest unsaved changes. Nothing is saved and no run is recorded, but preview messages are metered like normal runs. The form's Suggestions panel can also check your tools and model against your instructions -- see Create with AI.

Running an agent

• Chat -- Click the agent from your Agents list to open the chat interface. Type a message and hit send.
• API -- Use the REST API to run agents programmatically. See API Access.
• Schedule -- Set up a cron schedule or webhook to run the agent automatically. See Schedules.

Files and media

When an agent generates files (images, PDFs, CSVs, etc.), they appear in the chat and are saved to your Files library. You can download, view, and delete files from there. Files are shared within organizations but personal files stay private.

Platform Chat: sharing, stop, and rewind

• Share a chat -- Create a read-only public link that expires after 1, 7, 30, or 90 days, or never (30 days by default). See how many times each link was viewed and revoke links at any time. Viewers see the transcript; files appear by name only. Sharing is turned off for HIPAA organizations.
• Stop -- Stops the response on the server and keeps what was written so far.
• Regenerate, edit, and retry -- Rewinds the conversation to that message and runs it again.
• Files as they are made -- New files appear in the chat as soon as the tool that wrote them finishes, not only at the end of the response.
• Reconnects -- If your connection drops mid-response, the chat reconnects and picks up the response.
• Feedback -- Rate a reply thumbs up or down, with an optional reason. Ratings show up in Analytics, and thumbs-down replies can become eval cases.

Teams are multiple agents working together under a coordinator. Use teams when a task needs different kinds of expertise that a single agent cannot handle well.

When to use a team vs. a single agent

• A single agent with web search can research and write -- you do not always need a team.
• Use a team when members need different models, different tools, or different instructions.
• Example: a "Researcher" agent with search tools + a "Writer" agent with file generation.

Team modes

When creating a team, choose a mode that determines how the coordinator works with members. This is the most important setting for your team's behavior:

How to create a team

1. Create member agents first. Each member is a regular agent. Build them in Agents > Create Agent with their own model, tools, and instructions.
2. Create the team. Go to Teams > Create Team. Give it a name, choose a mode (see above), pick a coordinator model, and write team-level instructions.
3. Add members. Select existing agents as team members. For each member, write a role description so the coordinator knows when to delegate to them. Good role descriptions are critical -- they tell the coordinator what each member specializes in.
4. Run it. Chat with the team. The coordinator handles delegation and response synthesis based on the mode you chose.

Example: Research + Writing Team

Workflows are step-by-step pipelines. Unlike teams (where the coordinator decides what happens), workflows follow a fixed sequence that you define. Each step runs an agent or team. Beyond linear and parallel steps, the visual workflow builder supports control flow nodes: condition nodes for if/else branching based on a Python expression or a plain-English yes/no question, router nodes for dynamic path selection by route name or by a plain-English question, loop nodes that nest a body and stop when the stop condition is True or max iterations is reached, and nested workflow nodes that reference another workflow to run as a sub-workflow.

When to use a workflow

• You need steps to run in a specific order (Step 1 output feeds into Step 2).
• You want a repeatable process you can trigger with different inputs.
• Examples: content pipelines, data processing, report generation, multi-step analysis.

How to create a workflow

1. Create the agents you need for each step. Each step will run one agent or team.
2. Create the workflow. Go to Workflows > Create Workflow. Name it and optionally add an input template.
3. Add steps. For each step, select an agent or team, give the step a name, and optionally add an input template. Steps run in order from top to bottom. You can drag to reorder.
4. Set parallel or sequential. Between each step, click the connector label to toggle between then (sequential) and parallel. See below for details.
5. Run it. Enter your input and the workflow executes the steps, passing context forward.

Sequential vs. parallel steps

By default, steps run sequentially -- each step waits for the previous one to finish before starting. You can mark steps as parallel to run them at the same time as the step before them, which speeds up workflows where steps are independent.

Loops, conditions, and routers

These are containers, not sequential neighbors of their body. A Loop owns nested body steps; after it finishes, the next top-level step runs once.

Plain-English conditions and routers

Instead of writing Python, you can ask a question in plain English. In the step inspector, switch the step from Use an expression to Ask in plain English:

• Condition -- A yes/no question about the previous step's output (e.g. "Does the customer ask for a refund?"), with an adjustable threshold for how sure the answer must be.
• Router -- A question plus a short description of each route. Set a minimum confidence and a fallback route for when no route is a clear fit.
• Loop -- The stop condition can be a yes/no question too ("Stop when the answer is yes").

Questions are answered by the decision engine. If it can't answer, the run carries on safely -- a condition takes the else branch, a router takes its fallback route, and a loop runs to its maximum iterations -- and the run shows a warning.

Editing on the canvas

• Undo and redo -- Toolbar buttons, or Cmd/Ctrl+Z and Shift+Cmd+Z (Ctrl+Y on Windows). Deleting a step also offers Undo.
• Move to... -- Each step card has a menu to move the step into any branch, route, loop body, or group. Steps can also be duplicated and reordered with the arrow keys.
• Searchable pickers -- Find the agent or team for a step by typing its name.
• Test run -- Run the workflow from the editor and watch each step on the canvas go from pending to running to done, failed, or skipped. The test run uses the last saved version, so save your changes first.

Input templates

Input templates let you parameterize workflows. Use curly braces for variables:Write an article about: {topic}. When you run the workflow, you fill in the variables.

Example: SEO Content Pipeline

Knowledge bases let your agent reference your own documents and data. Instead of relying only on the model's training data, the agent searches your uploaded files and uses the relevant content in its responses. This is called RAG (Retrieval-Augmented Generation).

How to set up a knowledge base

1. Create a knowledge base. Go to Knowledge > Create. Name it and choose a vector database (LanceDB is the default and works well for most cases).
2. Add content. Upload files, add URLs or text, or connect a Google Drive or OneDrive/SharePoint folder. augLab splits the content into chunks and indexes it for search.
3. Connect to an agent. When creating or editing an agent, select your knowledge base in the Knowledge Sources section at the bottom of the form.
4. Use it. When the agent runs, it automatically searches the knowledge base for relevant content and includes it in the context.

Supported file types

PDF, TXT, Markdown, CSV, JSON, DOCX, HTML, and web URLs.

Cloud folders

Connect a Google Drive or OneDrive/SharePoint folder and pick it from the folder browser. augLab indexes up to 200 files of up to 50 MB each, up to 3 folder levels deep: PDF, DOCX, PPTX, TXT, Markdown, CSV, XLSX/XLS, and JSON. Google Docs, Sheets, and Slides are exported automatically. Folder and URL sources can re-sync on a schedule so the knowledge base stays current.

Test retrieval

Open a source and run a test query to see exactly which chunks an agent would get, with their scores and a citation for each (source, document, page, and chunk). Use it to tune your search and chunking settings -- see Advanced RAG. Embedding usage is metered.

When to use knowledge bases

• Your agent needs to answer questions about your company docs, policies, or product information.
• You want to ground the agent in specific data rather than general knowledge.
• You need the agent to cite specific sources from your documents.

Memory turns your agents into learning machines. When enabled, an agent automatically remembers user preferences, context, and facts across conversations — delivering personalized experiences that improve with every interaction.

How to enable memory

1. Open agent settings. Create a new agent or edit an existing one.
2. Enable Memory. In the Memory & Learning card, toggle “Enable Memory” on.
3. Choose a learning mode. “Always” automatically extracts and remembers information after every response (recommended). “Agentic” lets the agent decide what to save.
4. Select memory stores. Check which types of information to remember: user profile, conversation memory, session context, or entity facts.

Memory stores

• User Profile — Structured facts like name, role, company, and preferences. Updated as new info is learned.
• User Memory — Unstructured observations from conversations: communication style, project context, patterns.
• Session Context — Goals, plans, and progress for the current session. Useful for multi-step tasks.
• Entity Memory — Facts about external things like companies, projects, and people.
• Learned Knowledge — Insights that transfer across users. Shared team intelligence.

Viewing and managing memories

Open any agent and click the “Memories” tab to see what the agent has learned. You can filter by type, delete individual memories, or purge all memories for GDPR compliance.

HIPAA compliance

Memory is fully available for HIPAA-enabled organizations. All memory data is encrypted at rest, with additional field-level encryption for defense-in-depth. Memory data is subject to the same retention and purge policies as other PHI on the platform.

When to use memory

• Support agents that remember customer context and preferences across tickets.
• Personal assistants that learn communication style and project details.
• Sales agents that build up knowledge about prospects and companies over time.
• Any agent where returning users benefit from continuity.

Organize your agents, teams, workflows, skills, and knowledge bases into folders for cleaner navigation. Drag-and-drop items between folders in the dashboard, or use the MCP tools and Builder Chat to manage folders programmatically.

How folders work

• Each entity type has its own folder set (agent folders are separate from workflow folders).
• Folders are scoped to your personal workspace or to an organization.
• Deleting a folder does not delete the items inside — they return to "Unfiled".
• Items can be dragged between folders directly in the dashboard list views.
• The Builder Chat and MCP Server both support folder management via list_folders, create_folder, update_folder, delete_folder, and move_to_folder.

The Template Gallery (accessible via the "Marketplace" sidebar link) provides pre-built agent configurations that anyone can deploy in one click. Templates include a model, tools, and instructions — but never credentials.

Publishing templates

• Org templates — Org admins and owners can publish agents as templates visible to their organization. Use the "Save as Org Template" option in the agent card's three-dot menu.
• Platform templates — Superadmins can publish agents as platform-wide templates visible to all users. Use the "Save as Platform Template" option.

Using templates

Browse the Gallery, pick a template, and click Use Template. A new agent is created in your workspace with the template's configuration. You can then customize it further — change the model, add tools, edit instructions, or attach knowledge bases.

Every save of an agent, team, or workflow stores a full snapshot of its configuration: its settings, tools (with secrets removed), knowledge, skills, custom tools, team members, and workflow steps. Moving steps around on the canvas is not versioned. Open the Versions tab on any agent, team, or workflow page.

Draft and published

Your edits always go to the draft. Publishing pins a version for production:

• The published version runs on -- the API, schedules, webhooks, embeds, and MCP and A2A endpoints.
• The draft runs on -- dashboard chat and test runs, so you can try changes without affecting production.

Until you publish for the first time, every channel runs the draft, exactly as before.

What you can do

• Checkpoint -- Save a named version to come back to.
• Compare -- See what changed between any version and the draft, the published version, or another version.
• Restore -- Copy an old version into the draft. This creates a new version; production isn't affected until you publish.
• Publish and unpublish -- Publish the draft or any earlier version, or unpublish to go back to running the draft everywhere.

Publishing, restoring, and checkpoints need edit rights on the item. A workflow with no steps can't be published.

MCP and A2A endpoints

Turn on the MCP and A2A endpoint switch on the Versions tab to let other AI systems call one published agent, team, or workflow directly. The tab shows the URLs to copy:

• Needs the Team plan or higher, and the item must belong to an organization and have a published version.
• Callers sign in with an augLab OAuth token or an API key with the matching run scope (e.g. agents:run), and must be members of the organization.
• The MCP endpoint supports the core calls (initialize, ping, list tools, call a tool). Neither endpoint streams responses.

To give an AI client access to everything in your workspace instead, use the MCP Server.

Move agents, teams, and workflows between workspaces and organizations as bundles.

Exporting

Click Export on any agent, team, or workflow page to download a bundle: one JSON file with the item plus the agents, skills, and custom-tool definitions it uses.

• Secrets, MCP environment values, and credential overrides are removed. The bundle lists which credentials the importer will need.
• Knowledge sources are included as empty placeholders. Add their content again after importing.

Importing

Click Import on the Agents, Teams, or Workflows page and choose a bundle (up to 5 MB). A preview shows what will be created, which credentials you'll need to connect, and anything that would block the import -- nothing is created until you confirm. Your plan's limits apply.

Importing from OpenAI Agent Builder

The same dialog accepts an OpenAI Agent Builder export (the Agents SDK code export or the workflow JSON). This is a best-effort migration: the preview lists anything that didn't convert. Transform, set-state, and unrecognized nodes aren't supported, and file search and MCP nodes come across as placeholders for you to fill in.

Build your own tools that agents can call by wrapping any REST API endpoint. Custom tools let you connect agents to internal services, webhooks, or third-party APIs that aren't covered by the 90+ built-in integrations.

Creating a custom tool

1. Go to Custom Tools in the sidebar.
2. Define the HTTP method, URL, headers, and request body template.
3. Add optional authentication (API key, Bearer token, Basic auth, or OAuth).
4. Define input parameters that the agent will provide at runtime.
5. Test the tool with sample inputs before saving.

Using custom tools

Once created, custom tools appear in the tool picker when creating or editing agents. The agent receives the tool's name, description, and parameter schema, and can call it during conversations.

Evaluate and benchmark your agents systematically with eval suites. Define test cases, set scoring criteria, and track performance over time.

Key concepts

• Eval suite — A collection of test cases targeting a specific agent, team, or workflow.
• Test case — An input prompt with expected output or scoring criteria.
• Scoring — Exact match, contains, regex, LLM-as-judge, or custom criteria.
• Datasets — Reusable collections of test inputs, importable via CSV.
• Auto-eval — Run evals automatically on a schedule or after changes.

Running evals

Navigate to Evals in the sidebar, create a suite, add test cases, and click Run. Results stream in real-time with pass/fail indicators and detailed scoring breakdowns. Compare results across runs to track regressions.

Scoring rubric

Build the rubric from rows. Each row is one check with its own threshold and weight: LLM judge, contains text, matches pattern, exact match, valid JSON, or numeric minimum. An advanced view shows the rubric as JSON. LLM-judged checks need the Business or Enterprise plan.

Reviewing results

Click any result to open it: the input, the expected and actual output with the differences highlighted word by word, the judge's reasoning, and a pass/fail for each check. Filter to Failed or Regressed cases.

Building cases from real runs

• Click Add to eval on any run to turn it into a test case.
• In a suite's Cases tab, add thumbs-down replies from Platform Chat and runs with a low quality score as new cases.

Evals in CI

Start a suite run from your pipeline with POST /v1/evals/{suite_id}/runs. It returns 202 with a job ID; poll GET /v1/evals/{suite_id}/runs/{job_id} for the result. Pass an optional min_pass_rate to get a passed_threshold result you can fail the build on. A suite runs one eval at a time and tests the current draft. API keys limited to specific scopes need evals:run.

Embeds let you add an AI-powered chat widget or form to any website. Visitors interact with your agent, team, or workflow directly on your site -- no login required. You control which resource it connects to, allowed domains, and visual branding.

Embed types

How to create an embed

1. Go to Embeds in the sidebar and click Create Embed.
2. Choose the type -- Chat or Form.
3. Select the resource -- For chat and form (run mode), pick the agent, team, or workflow to connect. For form (knowledge intake mode), select the target knowledge source.
4. Configure fields -- For form embeds, define your fields: text, textarea, dropdown, radio buttons, checkboxes, toggles, and file uploads. Mark fields as required and set placeholder text.
5. Customize branding -- Set the primary color, color scheme (Light, Dark, or Auto to match each visitor's system setting), position (for floating widgets), welcome message, and placeholder text. The live preview shows the real widget with your unsaved settings; messages typed in the preview aren't sent.
6. Set allowed domains -- Restrict which websites can use the embed (leave empty to allow all).
7. Save and copy the snippet -- The embed token is shown once. Copy the HTML snippet and paste it into your website before the closing </body> tag.

Embedding on your site

Paste the generated snippet into your HTML. The widget loads asynchronously and renders inside a Shadow DOM, so it will not conflict with your site's styles.

Theme options

The widget loads its theme from augLab, so changes you make on the Embeds page reach installed widgets without reinstalling the snippet. Embeds run the published version of their agent, team, or workflow when there is one.

You can also override theme settings client-side by passing a theme object. Values set in the snippet take precedence over the dashboard:

Form field types

Form embeds support the following field types, configured in the dashboard:

• Text -- Single-line text input.
• Textarea -- Multi-line text area for longer content.
• Dropdown -- Select menu with predefined options.
• Radio buttons -- Single-choice selection from a group.
• Checkboxes -- Multi-choice selection from a group.
• Toggle -- On/off switch for boolean values.
• File upload -- Accepts files (configurable MIME types, max 10 MB per file).

Security

• Domain allowlist -- Restrict which origins can use the embed token. Requests from other domains are rejected.
• Token revocation -- Revoke an embed token at any time from the Embeds page. Revoked tokens stop working immediately.
• Shadow DOM isolation -- The widget renders inside a Shadow DOM so your site's CSS cannot interfere with the widget and vice versa.
• Accessible dialog -- The chat and form panels open as dialogs: Esc closes them, keyboard focus stays inside while they are open, and focus returns to the launcher button when they close.

Credentials connect your agents to AI model providers and third-party services. On the Business and Enterprise plans you bring your own model provider keys (BYOK) and pay providers directly, with no markup from augLab. On Studio and Team, models run on platform-managed keys and usage is billed through augLab, so you only add credentials for the tools and services your agents use. Credentials are AES-256 encrypted at rest and only decrypted in memory when they are used.

How to add a credential

1. Go to Credentials in the sidebar.
2. Click Add Credential.
3. Select the credential type from the dropdown (e.g. openai_api_key).
4. Paste your API key and save.

Your credential is now available to all agents that need it. If you are in an organization, credentials are shared with org members.

Credential types and where to get them

One-click OAuth connections

Several integrations use OAuth for a seamless, secure connection instead of manual API keys. Go to the Credentials page to see the available OAuth connections. Each connection is personal -- every user in an organization connects their own account. OAuth tokens are automatically refreshed so your connections stay active.

Schedules automate agent, team, and workflow runs so they execute without manual intervention.

Cron schedules

Run on a recurring schedule using cron expressions. Go to Schedules > Create Schedule, select the resource (agent, team, or workflow), define the input message, and set the cron expression.

Webhook triggers

Each schedule also gets a unique webhook URL. Send a POST request to that URL to trigger the run on demand. This is useful for integrating with CI/CD pipelines, Zapier, or other external systems. The request body becomes the input to the agent. In production, webhook requests must be signed with an X-Hub-Signature-256 HMAC of the raw body, and you can send an Idempotency-Key header so a retried request doesn't start a second run. See API Docs for details.

Viewing results

The Schedules page shows each schedule in plain English (e.g. "Every Monday at 9:00 AM"), with the next run time in the schedule's timezone and a link to the last run. All scheduled runs appear on the Runs page, and their output shows in the Inbox. Click any run to see the full conversation and any generated files.

The Inbox collects what needs your attention from the last 7 days, in three tabs:

• Needs input -- Approval requests you can act on, plus your own runs that are waiting on someone else's approval.
• Errors -- Runs that failed, errored, were cancelled, or were interrupted.
• Completed -- Output from your scheduled agents, teams, and workflows.

Approve or reject a request right from the Inbox. When you reject, you can add a reason.

The Approvals page

The Approvals page lists pending requests with a countdown to when each expires, the tool call's arguments, and a link to the run. Press A to approve or R to reject. Badges in the sidebar show how many requests are waiting. The Inbox and Approvals pages refresh every 15-30 seconds while they are open. The Approvals page needs the Orchestrator access level; anyone who is an approver can act from the Inbox.

If augLab restarts while a run is waiting at a before running gate, the request is kept, and approving it still starts the run. To set up gates, see Approval Gates.

Approval gates add human-in-the-loop checkpoints to your agents, teams, and workflows. When a gate is triggered, execution pauses and waits for a designated approver to approve or reject before continuing. This gives you fine-grained control over what your AI can do autonomously.

Gate types

Enforcement modes

Approver routing

Each gate specifies who can approve it:

• Entity creator — the user who created the agent, team, or workflow.
• Any org admin — any administrator in the organization.
• Specific user — a named user in the organization.
• Org role — anyone with a specific role (admin, owner, or editor).

Approvers receive an email notification when a request is pending and can approve or reject from the Inbox or the Approvals page.

Conditions

Gates can fire conditionally instead of on every run:

• Always — every execution triggers the gate.
• Input contains keywords — only fires when the input includes specific words (e.g. "delete", "production").
• Input matches regex — only fires when the input matches a regular expression pattern.
• Trigger source — only fires for specific trigger sources (e.g. API, webhook, or UI).

How to configure

1. Create or edit an agent, team, or workflow.
2. Expand the Approval Gates section.
3. Select a gate type (before running, before step, or before tool call).
4. Choose the enforcement mode (blocking or audit only).
5. For tool or step gates, select which tool or step to gate, or leave blank for all.
6. Choose who should approve and set any conditions.
7. Click Add Gate. You can add multiple gates to the same entity.

Gates can be configured before or after saving the entity. When configuring on a new entity, gates are queued locally and saved automatically when you create the entity.

Audit trail

Every approval request — whether approved, rejected, or expired — is recorded in the audit log with the approver, timestamp, resolution, and context. Sensitive data in the execution context is automatically truncated to maintain compliance.

The Runs page lists every agent, team, and workflow run you can see.

Finding runs

Sort the table and filter by type, agent/team/workflow, status, date range, cost, and duration. Filters are kept in the page address, so you can bookmark or share a view. Switch to the sessions view to browse conversations.

Comparing two runs

Select two runs and click Compare to see their inputs and outputs side by side with word-level differences, how the sequence of tool calls differed, and the change in tokens, cost, and duration. Compare needs the Builder access level.

From a run

• View trace -- Open the run's trace (one per turn when there are several). If none is linked yet, Find traces searches for them.
• Re-run -- Opens the agent, team, or workflow with the same input filled in. Nothing is sent until you send it.
• Edit -- Jump to the item's settings.
• Add to eval -- Turn the run into a test case in an eval suite.

Quality scores

Each completed run that produced output is scored automatically on five levels -- Fails, Poor, Partial, Good, Excellent -- with a separate check for whether the agent refused or stalled. The score shows as a badge on the run page; click it to see the answers. Analytics adds a quality score tile and a quality column for each agent, team, and workflow, and runs scored Fails or Poor are offered as eval cases.

Scores are an automatic judgment by the decision engine, not a ground-truth grade. To score what matters to you, open Quality rubric in the advanced section of the agent, team, or workflow form and add up to five yes/no or scale questions of your own.

Analytics

Analytics shows usage, cost, p50/p95 latency, errors, and thumbs-up/down feedback from Platform Chat. Click a breakdown row to open the matching runs, or an error count to open the failing traces.

Runs during a deploy

When augLab deploys an update, runs in progress get up to four minutes to finish. A run still going after that is marked Interrupted, keeps its partial output and usage, and appears in the Inbox Errors tab so you can re-run it.

Every agent, team, and workflow execution is automatically traced using OpenTelemetry. Traces capture the full execution flow -- every LLM model call, tool invocation, and team coordination step -- giving you deep visibility into what your agents are doing and how they are performing.

What gets traced

Viewing traces

Navigate to Tracing in the sidebar to see all your traces. The main page shows summary statistics (total traces, average duration, error rate) and a filterable list of traces. You can filter by time range (1 hour to 30 days) and status (OK or Error).

Trace detail and span waterfall

Click any trace to see its detail view. This shows a hierarchical span waterfall -- a tree of every operation that happened during the execution. Each span displays its duration as a proportional bar, making it easy to identify bottlenecks. Search spans by name, and select any span to see its details: the rendered model messages, tool calls and parameters, token counts, cost, and error messages.

Runs and traces are linked

From any run, View trace opens its trace; from a trace, View run takes you back. Workflow runs link to their traces too, including runs that failed. Tracing needs the Orchestrator access level.

Use cases

The decision engine is a fast judgment model that makes small decisions around your agents: how good a run was, which tools a set of instructions needs, which way a workflow should branch, or whether a tool result is trying to give your agent instructions. Each decision takes a fraction of a second. Your organization isn't billed for them.

Features and defaults

Changing modes

Go to Organization > Decision engine. Each feature can be Off, Measure only (the decision is made and recorded, but agents behave exactly as before), or On, where the feature allows it. The page shows what each feature measured over recent days, how often it fell back, and how long decisions took. Members can view the page; admins can change it.

If the decision engine is off, slow, or unavailable, every feature falls back to how augLab works without it.

Organization admins decide who can do what, what agents may say and do, and how much they can spend. These settings are under Organization in the sidebar. Beyond the guardrail defaults below, everything here is opt-in: an organization that changes nothing works as before.

Roles

• Viewer -- Sees shared agents, teams, workflows, and their runs. Can't run or change anything.
• Runner -- Everything a viewer can do, plus run agents, teams, and workflows.
• Member -- Everything a runner can do, plus create items and edit or delete shared items.
• Editor -- Everything a member can do, and can edit any shared item even when shared editing is restricted.
• Admin -- Everything an editor can do, plus members, policies, budgets, and alerts.
• Owner -- Everything an admin can do, plus billing and deleting the organization.

Admins can assign any role except owner. Admins also give each member an access level -- Explorer, Operator, Builder, Orchestrator, or Leader -- which controls which parts of the dashboard they see. Owners and admins always have Leader.

Restrict shared editing

Off by default, so any member can edit shared items. Turn it on (on the Guardrails page) and only the item's creator, editors, admins, and the owner can change shared agents, teams, workflows, skills, knowledge, and custom tools. Private items are always editable by their creator only.

Guardrails

Set an organization-wide policy, with overrides per agent or team in the form's Advanced section. Turn on Agents can only make these stricter so an agent's own settings can tighten the organization policy but never loosen it. You can preview unsaved changes on sample text before saving.

• On by default -- Masking of Social Security and card numbers in input, and blocking of a short list of jailbreak phrases in the person's own message. Inside team and workflow runs, hand-offs between agents aren't checked for jailbreak phrases.
• Opt-in -- Masking or blocking other personal data in input and output, extra injection patterns, an AI classifier for injection attempts, denied terms and topics, OpenAI moderation, and treating tool output as untrusted data. The AI classifier and moderation use OpenAI and are skipped for HIPAA organizations unless OpenAI is an approved provider.

Budgets

Set a monthly spending cap for the organization and for individual agents. There are no caps until you set them. When a cap is reached, new spending is blocked with a clear message unless Allow spend past the cap is on. Caps are also checked during a run, after each model call. Budget alerts go out at 80% and 100% by default.

Alerts

Send alerts by email, to Slack, or to a webhook signed with an HMAC signature; admins also see them in their Inbox. The budget rule is on (it fires once a cap exists); run failure rate, eval regressions, and long-waiting approvals are off until you turn them on. Rules are checked every 5 minutes. Use Send test to check a channel, and see recent alerts on the same page.

Run agents, teams, and workflows programmatically from your own applications.

Getting an API key

Go to API Keys in the sidebar, click Create API Key, and give it a name. Copy the key immediately -- it is only shown once.

Making requests

Include the key in the Authorization header:

Endpoints

Continuing a conversation

Send back the session_id from a previous response to continue the conversation. For agents and teams, up to the last 10 turns are replayed as context. Streaming responses return the ID in the X-Session-Id header.

Async runs and webhooks

Add "async": true to get 202 and a job_id straight away, then poll GET /v1/jobs/{job_id}. Add a callback_url (HTTPS) to receive a signed POST when the run finishes instead of polling:

• Headers -- X-AugLab-Event (run.completed or run.failed), X-AugLab-Delivery (the same across retries), X-AugLab-Timestamp, and X-AugLab-Signature.
• Signature -- sha256= followed by the hex HMAC-SHA256 of {timestamp}.{body}, using your callback_secret or the webhook_secret returned once when you started the job.
• Retries -- Failed deliveries are retried after 5 seconds, 30 seconds, 2 minutes, and 10 minutes.
• HIPAA organizations -- Webhooks carry the run status only, not the output.

Async jobs don't survive a platform restart. A job that never finishes is reported as failed, so check the status and start it again if needed.

Evals from CI

Run an eval suite from your pipeline and fail the build on a minimum pass rate. See Evals in CI.

Rate limits

By default each key can make 60 requests per minute from each client IP address. Organization admins can also set a limit for a key across all IP addresses and a monthly quota (through the API for now).

For the full endpoint reference with request/response schemas, visit API Docs in the dashboard.

augLab can act as an MCP (Model Context Protocol) server, allowing you to connect external AI clients like Claude, ChatGPT, Cursor, and others directly to your augLab agents, teams, and workflows. Instead of switching to the augLab dashboard, you can run your entire AI workforce from within whatever tool you already use.

How it works

MCP is an open protocol that lets AI applications connect to external tools and data sources. When you add augLab as an MCP server, your AI client discovers all available tools (agents, teams, workflows, skills, knowledge) and can call them directly during conversations. Authentication uses OAuth 2.1 with PKCE — your client handles the flow automatically.

Quick setup

Available tools

Once connected, your MCP client can use these tools:

Managing connections

Go to MCP Server in the dashboard sidebar to see your server URL, all connected apps, and revoke access for any app. Every MCP tool call is audit-logged for compliance and debugging.

Requirements

• A Team, Business, or Enterprise plan is required.
• 40 tools are available covering agents, teams, workflows, memory, skills, knowledge, folders, and execution history.
• When HIPAA mode is enabled, the same token verification, audit logging, MFA enforcement, and encryption safeguards apply to MCP.
• To expose a single agent, team, or workflow as its own MCP server or A2A agent, see Versions & Publishing.
• Org-level permissions are enforced — users can only access agents and resources they have permission to.

Skills are reusable knowledge and instruction packages that augment an agent's behavior. They give your agent domain-specific expertise, standard operating procedures, or specialized know-how that goes beyond its base instructions. Think of them as "plug-in expertise" you can attach to any agent.

What's in a skill?

Each skill has three parts:

How to create a skill

1. Go to Skills > Create Skill.
2. Use the AI Generate button to auto-generate structured instructions from your description, or write them from scratch.
3. Give it a name and optional description so you can identify it later.
4. Write instructions -- detailed guidance for the agent on how to use this skill. Be specific about processes, rules, formatting, and expected behavior. Use the AI Generate button to auto-generate structured instructions from your description.
5. Optionally add reference documents -- supporting materials like style guides, templates, or product data.
6. Optionally add scripts -- code files the agent can reference or execute.
7. Save the skill.

How to attach a skill to an agent

When creating or editing an agent, scroll to the Skills section at the bottom of the form. Select one or more skills to attach. The agent will have access to the skill's instructions and reference materials during every conversation.

Example use cases

Skills vs. instructions vs. knowledge bases

• Agent instructions -- general behavior and personality for a specific agent.
• Skills -- reusable expertise packages you can attach to multiple agents. Good for processes and domain knowledge.
• Knowledge bases -- large document collections the agent can search. Good for FAQs, documentation, and reference data.