Skip to main content

Axleon AgentOps

Guide

Learn to build agents, connect tools, and use your Agents in conversations and applications.

Start here

Axleon AgentOps manages Agents that answer requests and use tools. Read this guide without signing in. To start a Chat, sign in and choose an Agent in Chats; to build your own, follow the steps below.

1. Sign in and check your access

Open the address provided by your organization and use the sign-in method shown. Profile → Account shows your tier, and Profile → Usage shows your usage and limit. New accounts normally start as guest; if Agent creation or execution is unavailable, ask an administrator to change your tier in Members.

2. Create a small first Agent

In Agents, choose New Agent and enter an identifier and display name. Start with a short task whose expected answer you can judge before adding tools.

3. Save, run, and inspect

Set a model and instructions in the Playground, save, and try a short request. Check the answer, warnings, usage, and tool activity. The Run panel uses saved settings.

4. Connect callers

Saved Agent settings are ready for Chat and configured integrations. For HTTP calls, issue an Agent token in Integrations and follow API Reference.

Work with an Agent

Each Agent stores its model, system prompt, capabilities, and execution limits in one current configuration. Visibility, integrations, and usage belong to the Agent.

Conversation and tools

Use agent when a task requires conversation, searches, tool calls, or delegation. Write its role, task boundaries, and expected output in the system prompt, then send the task as a message. The model chooses whether to use the tools made available to it; enabling a tool does not guarantee a call.

Image generation and editing tools

Enable image tools and select an image model. Ask the Agent to generate an image, or attach a picture and request an edit. The same Agent can handle these requests in Playground, Chat, and execution APIs.

Configure an Agent

Edit the Agent’s current settings in the Playground and save them. To experiment independently, clone the Agent and configure the copy.

Model and fallback

Select a text model with tool calling support. Reading pictures also requires image input. Configure a compatible fallback if needed. Image generation and editing use the separately configured image tool model.

Automatic model selection

An administrator assigns shared tier models, task policies and budgets in Settings → Models → Usage settings. A decision model can choose among those tiers. Enable model routing in the Agent and save; selection occurs before the first response. Missing or failed decisions use its main model when that model satisfies the required capabilities and budget. Turning routing off keeps the main model; Restore default also removes ModelTask. Inspect the chosen model and routing decisions in Traces and Usage.

Preview and save are different

Prompt preview assembles the current draft. It does not generate an answer, but memory recall and capability discovery can contact configured services. Save before running; the Run panel uses saved settings.

Control run size

Set output length and agent turn limits to match the task. Presence penalty is an optional control for repeated tokens when the selected model supports it. Turn and output limits can leave a partial answer; a deployment deadline can stop the run with an error. Read completion reasons and warnings. Reasoning trace controls displayed reasoning, not whether the model reasons.

When saved settings take effect

The next run uses the saved settings. Each Agent keeps the settings read when it is prepared; a local subagent reads its settings when called. Pending approvals reject changed settings or connections. Concurrent edits produce a conflict; reload before saving again.

Add skills, tools, and other agents

Administrators register capabilities on Skills, Tools and Plugins. Agent owners bind the available entries to an Agent, save, and test a task that needs them. Registration alone does not expose every capability to every run.

Skills: reusable instructions

Have an administrator create a shared skill on Skills with a clear description, then bind it in the Agent settings editor. For a procedure only one Agent needs, the Agent owner writes a dedicated skill under Dedicated skills in the same editor; it is bound at once and other Agents cannot use it. The model initially sees the name and description and can load the full instructions when needed. Use skills for repeatable procedures and domain guidance, and verify that the task actually causes the intended skill to be loaded.

MCP: discover and select tools

Have an administrator register the server on Tools and check that discovery lists the expected tools. Bind the server to the Agent, select the tools to expose, and save the settings. If calls fail, inspect the server status, required headers, and run warnings. A reachable server can still return no usable tools or require authorization.

MCP connection settings have different scopes

Only the Agent owner can change tool selections, header overrides and file-response mappings, then Save with Agent settings. Refresh tools after changing headers. Masked values preserve saved secrets; an empty map removes overrides. OAuth connect/disconnect actions save immediately. Administrators configure any required OAuth app in Tools; members authorize their own accounts in the Agent’s MCP Settings or Integrations → My MCP connections, including on Agents created by others. Calls use the caller’s personal authorization.

Delegate to another agent

Bind another configured Agent when the task benefits from a specialist. Give each delegate a precise description. Delegated activity is labelled by author, with usage attributed to the originating run.

Import and synchronize plugins

An administrator imports skills and MCP definitions from a configured repository or an uploaded checkout archive in Plugins. Use archive upload when the repository is unreachable. Inspect skipped/invalid entries and bind imported capabilities to your Agent. Imported skill content and MCP URLs/descriptions are maintained at the source and synchronized again; configure credentials separately in the console, because MCP headers are not imported. Sync does not delete orphaned entries automatically; review and remove them explicitly from its results.

Dynamic discovery and memory

Dynamic discovery matches recent user requests against capability names and descriptions (using the system prompt only when no request is available), then adds relevant skills and MCP servers/tools without changing saved bindings. A precise description is the routing signal: say when the capability should be used and what it returns. It needs a working capability catalog and embedding setup; ask an administrator if results are missing. Memory recall is separate and needs a bound MCP server offering recall.

Image, URL, and file tools

Enable image generation, URL reading, or Slack history when needed and configure the corresponding services. With file storage configured, File reads, creates, and edits supported documents, while SaveFile creates text files. Document processing itself is built in and needs no MCP binding. Audio processing and coding Workspaces are Agent Knowledge and Agent Forge Tools.

Chats and attachments

The Chats page keeps your Chat history with Agents. Use Playground for configuration tests and a Chat for work that continues over multiple messages.

Choose an Agent

Choose an accessible configured Agent. You can change the Agent before any message in a Chat: the next message asks the chosen Agent, which continues the same conversation, and the thread marks where the Agent changed. You cannot change it while an approval is pending. With a decision model selected in Settings → Models → Usage settings, the Chat composer suggests an Agent from your typed request, including follow-up messages. Recognized PII patterns are masked before the request and candidate descriptions reach that provider. Suggestions never change your selection automatically. Click Use Agent or choose manually. The previous suggestion stays visible while a new result is pending; a completed result without an available Agent clears it. Each Chat turn uses its Agent’s current saved settings.

Chat history has limits

Display messages and the model’s encrypted SDK Session are separate. The Session supplies bounded prior turns, tool results and recent images; Memory is an optional long-term source. Omitted history produces a warning. If the Session has expired, visible messages are not rebuilt into model history. Restate essential constraints when starting again.

Images and documents

Attach PNG, JPEG, GIF, or WebP images to a model that supports image input. PDF, UTF-8 text, DOCX, XLSX, PPTX, HWP 5.x, HWPX, ODT/ODS/ODP, and RTF are read by the built-in document engine. Attach up to four documents of 10 MiB each. The Chat retains bounded extracted text; configured storage also keeps the originals. Check extraction and storage warnings after sending.

Create a new document

In an Agent Chat, ask “Create a DOCX report from these notes” or “Make an XLSX budget table.” DOCX, PDF, PPTX, HWPX, and XLSX creation is built in. Plain text, Markdown, CSV, JSON, HTML, and SVG use SaveFile. File tools require configured storage. Download the result from the response and review its contents and layout. HTML previews run immediately in an isolated frame. Stop and Restart control execution; preview changes are not saved to the original.

Edit an attachment and keep the original

Attach the source, then ask “Inspect this document and change the heading to Quarterly results” or “Set Summary!B2 to 150.” DOCX, PPTX, and HWPX support selected text changes; XLSX supports cell changes; UTF-8 text supports unique substring replacement. The agent inspects targets and returns a new file. Follow-up requests can use the original or revised file.

Know the editing limits

Reading a format does not guarantee editing it. PDF, HWP, ODT/ODS/ODP, and RTF have no source-preserving editor. Signed documents and macro workbooks are rejected for editing. Document text edits cannot add paragraphs or line breaks, and formulas are not calculated. Text changes may alter layout; review the downloaded result. Extracting text and rebuilding a document does not preserve its original formatting.

Closing the page does not stop a Chat run

Use the Chat's stop control to request cancellation. Navigating away or closing the browser tab only disconnects the view; reopen the Chat to read the saved result. Cancellation cannot undo actions a tool has already completed. A server interruption can still prevent an active run from finishing.

Tool approval and resuming a Chat

An Agent can require approval before selected tools run. Review the agent, tool and arguments in the Chat, then approve or reject. When you reject a call you can tell the Agent what to do instead; it continues the same run with your instruction. An Agent can also stop to ask you its questions with AskUser, all in one form with what it found and the values it suggests filled in: answer them and continue, answer in your own words instead, or decline to answer. An SDK approval pauses new messages until resolved or discarded. Changing the settings or connection can invalidate a pending checkpoint. Protected Git actions in Agent Forge are approved in the Forge console, not in the Chat.

Steer a running Agent

While the Agent works, type in the input and send. The Agent reads your message before its next step and continues the same run. A small check in the message's lower-right corner brightens once the Agent reads it. If the run finished first, a warning mark and "Send as a new message" appear. Steering takes text only.

Execution surfaces do not share every capability

Execution surfaces share the Agent settings. Authentication, conversation history, personal context, service access, and approval interfaces follow each surface’s rules.

Chats: persistent history and approval return

The signed-in chat owner receives a persistent SDK Session and tool approval UI. Long work that an Agent service accepts returns its result to the source chat.

Playground and APIs: saved input, caller-owned history

Playground runs saved settings as the signed-in user. Personal Agent API tokens run as their issuing Studio account. Agent service Tools use that user’s current access. HTTP clients supply their own history.

Messengers: platform identity and replies

Slack, Telegram and Teams preserve the platform sender as the actor. Send the bot a private message; it replies with a one-time link. Open the link, sign in to Studio and confirm the connection. Runs use the linked Studio account and current Agent access. Plain email text does not authenticate a caller.

Webhooks and schedules: machine actors

Webhook calls run as the issuer of a personal Webhook token. GitHub signs the delivery with that token and uses its personal URL, including the credential selector. Schedules run as the user who registered them. Current account, source credential and Agent access are rechecked before new effects. Results appear in Integrations history.

Agent services

Agent Memory, Agent Knowledge and Agent Forge are separate services. Studio signs you in to them and connects them to Agents as Tools. Each service keeps its own settings, work and history.

Connect a service to an Agent

An administrator connects the services in the deployment. Each connected service appears in Tools. Add its Tool to an Agent. The Agent then works in the service with the permissions of the user who sends the message.

Change service settings in the service

Audio processing profiles, Workspace profiles and protected Git approvals belong to the service. Open Tools, select the service and use its Settings or History link. Studio keeps no copy of these settings or records. Your Git accounts are the exception: connect them once in Profile → Git accounts, and the services use that connection for your Git work.

Give a chat file to a service

Attach the file to the chat and ask the Agent to use it. A meeting recording can be attached the same way, for example to ask for a transcript or meeting notes. The Agent gives the service a short-lived file reference, and the service reads the file directly from Studio.

Receive long work in the chat

A service can accept long work, such as a transcription or a coding run, and finish it later. Studio adds the result to the chat that started it. Open the service's History link to see the full record.

Call an Agent over HTTP

API Reference is built into each Agent and fills in its address. It contains request fields, response shapes, error codes, and curl or SDK examples. Use it alongside the steps here; no source checkout is needed.

Prepare the Agent and credential

Save the tested Agent settings and issue your personal API token in Integrations. Your account must currently allow API tokens and have access to the Agent. Send Authorization: Bearer <token>. Execution, MCP caller context, Agent service access and personal usage belong to the issuing user ID. A token does not create a browser session.

Use the Agent address

Execution URLs start with /api/agents/{name}/ and use the Agent’s current saved settings. Send the task in messages. Use the Axleon AgentOps host reachable from the calling system.

Send the task as messages

Send {"messages":[{"role":"user","content":"Summarize these notes"}],"stream":false} to predict. Include supported inline image parts when needed. Images are generated or edited by the Agent’s image tools. Begin with one request and inspect its answer, warnings, and usage.

OpenAI-compatible clients

Use chat/completions and the Python or JavaScript examples in API Reference. Set the SDK base URL to the Agent address and the API key to its token. Saved Agent settings determine the model and sampling parameters; model, temperature, and max_tokens do not override them. Set AGENT_API_TOKEN and CONVERSATION_ID in the calling process environment before running the examples.

Streaming and conversation history

For text predict or chat/completions, stream:true returns SSE; agent also provides an endpoint for streaming text and tool activity. Keep the connection open and handle warning, error, and completion events, because HTTP 200 alone does not prove the run succeeded. HTTP callers send their own message history. X-Conversation-Id can preserve downstream MCP conversation identity, but does not load past messages for you.

Check the result and protect the token

Inspect usage, warnings, and the completion reason as well as the answer. turn-limit or output-limit on predict means a partial result; chat completions reports length for limit stops. Download file results before their links expire. Keep tokens in the calling server's secret storage. Regenerating or revoking an Agent token invalidates the old token immediately, so update every caller. Inspect token totals in collected OpenAI responses or the Usage page.

Bots and automation

Agent owners configure shared integrations, while each user manages their personal MCP connections. Save the Agent settings first and verify one real call after setup. External platforms need their own credentials and network connectivity; they are optional in an offline installation.

Slack

For an Agent, copy the app manifest from Integrations, create and install the dedicated Slack app, and save its bot token and signing secret. Enable events, check the displayed events URL, and run Test connection. Invite the bot to the target channel and mention it. A successful credential test does not prove Slack can deliver events to the application.

Telegram and Teams

In an Agent's Integrations, save and enable the Telegram bot token; enabling registers its webhook. Use Register webhook again after an application URL change. For Teams, enable the Azure Bot's Teams channel, save its application ID and client secret (plus tenant ID for a single-tenant app), and set its messaging endpoint to the displayed URL. Test in a direct conversation before trying group mentions.

Receive a webhook

Issue your personal Webhook token in Integrations to enable calls; revoke it to stop them. Generic callers send X-Trigger-Secret; GitHub uses the same secret to sign X-Hub-Signature-256; GitLab sends it as X-Gitlab-Token from its Secret token field. The JSON payload becomes a user message. HTTP 202 acknowledges delivery; check Trigger history for execution and skipped runs. With overlap disabled, deliveries arriving during a run are skipped.

Schedule a recurring task

In Agent Integrations, add a schedule with a five-field cron expression, an IANA time zone such as Asia/Seoul, and the message to run. Select any delivery destinations and enable it. Schedules use the current Agent configuration and require the deployment's external ticker. Check both run status and delivery results: a generated answer can succeed even when sending it to a bot fails.

Results, usage, and limits

Find originals and generated files

Personal Artifacts includes files attributed to your email, including personal-context automation. Agent Artifacts also includes outputs without a personal owner. Private audio files that Studio stored earlier can only be read or deleted by their owner. Reopen an ordinary artifact to refresh an expired signed link; this does not restore an expired or deleted file. Download files you need beyond retention. Deleting a chat does not delete its artifacts.

Understand usage and attribution

Agent Usage shows model/provider totals and caller details for owners. Profile → Usage combines Chat, personal API/Webhook tokens, messaging and schedules under the same Studio user ID. Costs use provider-reported amounts or model pricing. Missing usage is uncertain; a zero estimate does not prove a free provider call.

Alerts, blocks, and concurrent runs

Agent Settings separates daily/monthly alert and block thresholds. Alerts notify when a destination is configured; blocks refuse new runs until the UTC day or month resets, even without notifications. Personal tier limits and caller concurrency limits also apply where relevant. Costs can arrive after a run finishes, so thresholds are not a prepaid balance that guarantees no overspend.

Investigate a run in Traces

Owners can inspect preparation, model calls, tools, delegates, durations, usage, and warnings in Agent Traces. Every Agent run is traced; prompts and tool output are not stored in full. A missing trace can mean the request was refused before execution started or the trace could not be stored.

Access and sensitive data

Choose access rules before sharing an Agent or connecting data sources. The console, model provider, tools, and file store are separate places where information may be processed.

Public, private, and editing rights

A public Agent is accessible to signed-in users of this installation; it is not anonymous access to every API. Private Agents are accessible only to their owner. Owners manage Agent settings, integrations, traces, and Agent-wide artifacts. Machine credentials have their own access rules.

Secrets and shared links

Saved keys display four characters at each end; values of eight characters or fewer remain hidden. Replace opens a separate draft, and clearing or cancelling the draft keeps the saved key. Agent and Webhook credentials issued by this service share Show, Hide, Copy and supported generation or revocation controls. Copy appears only while plaintext is shown; replacement and revocation require confirmation. Browser preferences do not store credentials. Treat signed artifact URLs as credentials too.

PII filtering is a limited protection

The Agent’s PII filtering tokenizes or redacts recognized values before sending model text, or blocks the request. Each Agent sets the data types, custom rules, and whether readers and tools get original values. It is not complete anonymization: by default, tool arguments, saved answers, reasoning and files can contain restored data. Use approved model and tool services for sensitive work.

Private services need explicit network access

Ask the deployment operator to allow the specific internal DNS suffix when a legitimate internal service is blocked. MCP servers use MCP_INTERNAL_HOST_SUFFIXES; URL reading uses URL_FETCH_INTERNAL_HOST_SUFFIXES. They are different settings. A declared host must still be reachable and authorized; an allow entry does not supply credentials or open a firewall.

Administrator settings

Members, Settings, Models, and Audit serve different purposes. Changes here can affect multiple Agents, so verify the affected path after saving. Signed-in users, including guests, can browse registries; creating and maintaining their entries is an administrator task.

Manage member tiers

In Members, find the user and change the tier when they need Agent creation or API-token access. The user checks the resulting limit in Profile → Usage. Administrators listed in ADMIN_EMAILS have a fixed admin tier; removing an email from the list does not automatically demote its stored tier. The Teams tab creates Studio teams and sets their members and managers. Directory teams come from enterprise profiles: you can only choose their managers, and a directory change applies when the member signs in again.

Settings overrides and deployment values

Settings groups Service, Access, Plugins and Models. Service manages branding, public addresses, artifact delivery, run limits and Slack progress text. Access manages administrators and allowed domains. Plugins manages its GitHub repository and token. Models assigns usage roles to central selections, sets search score floors and controls missing-price policy. Only changed fields are saved. Deployment settings own the database, encryption, sign-in, storage and service connections.

Connect and verify models

Open Agent Models from Settings → Models → Central model management. Register provider connections there, collect their models and enable the models this installation may use. In Studio, Usage settings assigns default, decision and search roles. The decision model supports Agent suggestions and routing. Routing tiers, task policies and budgets apply to Agents that enable routing.

Browse, select and maintain models

Models shows the models enabled in Agent Models. Compare Tools, Vision and Reasoning capabilities, context limits and prices. Sort by name or price, filter by provider or type, and mark personal favorites. This browser remembers filters and view settings; favorites follow your account. Use the refresh control after central selections change. A successful listing does not prove inference works; verify with a short Agent run.

Catalog and retrieval in an offline deployment

Studio reads selected models from the internal Agent Models service. Internal providers work without the public internet. Public discovery in Agent Models is optional and never enables a model automatically. Capability search needs an enabled search service and a selected embedding model; rerank is optional. Changing the embedding model requires reindexing. Models that are not selected and enabled are refused. Usage settings controls whether selected models with unknown prices may run; an unknown price does not mean free.

Choose how users reach artifacts

Set PUBLIC_BASE_URL to the application's user-facing address. In Settings, proxied artifact access sends bytes through the application and suits a store that browsers cannot reach. authenticated returns an expiring storage URL, so browsers need direct storage access. public requires public-read storage policy and lets anyone with the URL read it. Validate by generating, reopening, and downloading a file from a user's network.

Review administrative changes

Use Audit to inspect the selected date range, actor, action, target, and details. Credential reveal operations are recorded as well. Use these records to identify who changed configuration or accessed an issued secret, and use Agent Traces for execution diagnostics. Retention limits apply to both kinds of record.

Install Axleon AgentOps

This section is for the deployment operator. Console users need the application address and an account. Obtain the release image and the deployment-specific launch, secret, ingress, and backup settings from the package provider.

1. Prepare the services and image

Prepare a versioned release image and PostgreSQL with pgvector (the deployment baseline is PostgreSQL 18). Mirror the image into an internal registry for isolated operation. Agent execution additionally needs a reachable, supported model provider registered after sign-in. Add S3-compatible storage for persistent files. The deployment owns credentials, volumes, TLS and routing.

2. Supply required configuration

Supply DATABASE_URL and AES_ENCRYPTION_KEY through the deployment's secret/configuration mechanism. AES_ENCRYPTION_KEY must encode 32 bytes in base64 and remain stable across restarts. Model connections are registered after sign-in. Set STAGE explicitly (prod for production); alpha/prod also requires ADMIN_EMAILS and a sign-in method. Set AUTH_SECRET to a stable session secret and AUTH_BASE_URL and PUBLIC_BASE_URL to the user-facing application address in the deployment environment before configuring callbacks.

3. Configure sign-in

For offline operation, configure internal OIDC (including Keycloak) or password sign-in. OIDC uses OIDC_ISSUER, OIDC_CLIENT_ID, and OIDC_CLIENT_SECRET; register /api/auth/callback/<OIDC_PROVIDER_ID> (default oidc). Keep the provider ID stable for existing accounts. Google can also use GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET. Password bootstrap uses AUTH_PASSWORD=true, BOOTSTRAP_ADMIN_EMAIL, and BOOTSTRAP_ADMIN_PASSWORD; include the email in ADMIN_EMAILS. Existing passwords are preserved.

4. Connect persistent file storage

For persistent files, create a bucket and set S3_BUCKET_NAME. For a non-AWS store, also set S3_ENDPOINT, S3_ACCESS_KEY_ID, and S3_SECRET_ACCESS_KEY. AWS S3 can use the deployment's AWS credential or role configuration. Grant the storage identity read, write, and delete access to artifacts/* in that bucket, and read and delete access to source-files/* while private files that Studio stored earlier remain. Keep non-AWS storage keys in the S3 fields rather than AWS_* variables used by other providers. Select the artifact access mode in Settings and verify downloads from the user's network.

5. Start and verify the full path

The application validates configuration and applies database schema migrations on startup. Check health and readiness, then sign in as the administrator. In Agent Models, register a provider and enable a model. In Studio, choose its default role in Usage settings, then create and run a small Agent. If storage is configured, reopen a generated file. Test internal MCP and each enabled integration.

Operate, retain, and upgrade

The deployment operator owns monitoring, scheduled calls, backups, and rollouts. Configure these alongside the application rather than assuming that saving a console setting starts background infrastructure.

Health is not a successful model run

GET /api/health checks process liveness. GET /api/ready checks database connectivity, credentials and schema, returning 503 on a failed check or while draining. It does not contact model providers, so provider outages leave sign-in, Settings and the console available. Verify model credentials and inference with a short Agent run.

Run the external ticker

Set SCHEDULE_SCAN_TOKEN and configure an external scheduler to POST /api/triggers/scan with X-Scan-Token at least once per minute. Setting the token alone starts nothing. This call drives schedules and expired database-row cleanup. A missing deployment token returns 503; an absent or incorrect request token returns 401. Check scan results and trigger histories after enabling it; long outages do not replay every missed occurrence.

Refresh the capability index

If capability discovery is enabled, configure a separate hourly POST /api/catalog/reindex with the same X-Scan-Token credential. The schedule scan does not perform this reindex. A successful response starts background indexing; inspect the server log for indexed, removed, or undiscovered entries, then test a question that should discover a newly registered capability.

Database retention and file lifecycle

Database retention settings control trace, usage, chat, artifact, trigger and audit rows. Keep ordinary artifact retention at least as long as chat retention and configure matching object lifecycle rules. Private audio files that Studio stored earlier keep their own expiry; the schedule ticker deletes them when it expires. Do not apply blanket object expiration to source-files/ in the shared Artifacts bucket: deletion barriers must remain.

Back up data and recovery keys

Back up PostgreSQL, stored objects, deployment configuration, and the encryption/session secrets under restricted access. Restore them together in a separate environment and verify sign-in, credential decryption, Agent runs, and file access. Losing or arbitrarily replacing AES_ENCRYPTION_KEY makes stored credentials unreadable. An application image is not a data backup.

Upgrade with a recovery plan

Record app image versions and verify backups before deployment. Prepare any data migration required by the target release and stop the app while applying it. Recheck sign-in, runs, files and approval continuation. Recovery uses a compatible image and database backup. Retain current and recovery images; clean unused caches when disk capacity requires it.

Troubleshooting

Start with the failing surface, the exact error, and whether the run began. Change one relevant setting at a time, then repeat the smallest request that demonstrates the problem.

Sign-in fails or a control is unavailable

Check your sign-in method, allowed email domain and account with the administrator. A missing control can be a tier or ownership restriction. For API 401 check your personal token and Agent name; for 403 check the issuing user’s current access. For bots, connect your messaging account in Profile → Messaging. An inaccessible private Agent can return 404.

A model is missing or a call fails

Check the selection in Models and refresh the list. An administrator can inspect its connection and model settings in Agent Models. Confirm the provider address, key, exact model ID and supported operations. For 400, compare the request and image/tool requirements with API Reference. For 503, check the Studio-to-Models and identity connections. Do not repeat an uncertain paid request; inspect its usage receipt.

429, timeout, or an incomplete answer

For 429, inspect concurrent runs, Agent daily/monthly blocks, and personal tier usage; follow Retry-After on API responses. For a timeout or stream error, inspect the provider, slow tools, and deployment deadline. For turn-limit, output-limit, or length, narrow the task or adjust the saved settings's appropriate limit. Avoid blind retries when a tool may already have changed external data.

A tool or memory is not used

Check saved bindings, tool selection, Prompt preview, OAuth connections and run warnings. Test a request that needs the tool. Memory requires an explicitly bound server offering recall. File is built in and requires configured storage; it needs no MCP binding. Ask the operator about blocked internal hosts.

A bot or schedule is silent

A webhook 202 acknowledges admission, not completion. Inspect status and Trigger history: accepted, duplicate, busy, no-configuration, ping or ignored. GitHub PR review mode requires a GitHub signature, and GitLab merge request review mode requires X-Gitlab-Token from the configured GitLab host; generic callers use X-Trigger-Secret only in ordinary mode. A GitLab review answered 409 review-not-ready names the Git host the caller must connect in Profile → Git accounts. Schedules and the delivery of Agent service results require the ticker.

Attachments or downloads fail

Check the file type and upload limits first. An image needs an image-capable model; Office reading uses the built-in engine. Password-protected files, scans needing OCR, and unsupported edits require another workflow. If File is unavailable or the original was not kept, ask the operator to check storage configuration. For download failures, reopen Artifacts and check storage warnings, access mode, public base URL, connectivity, and retention.

What to send for support

Record the application version, Agent, execution surface, time and time zone, error/status code, trace ID, and a minimal reproducing request. Include the expected result and whether Playground also fails. Remove tokens, cookies, private file links, and sensitive content.