Introduction
Welcome
Abundly is an enterprise-grade platform to build, configure, manage, and collaborate with autonomous AI agents — an operating system where teams of humans and AI agents work side by side. Unlike simple tool-enabled AI chat, Abundly agents offer true autonomy (schedules, triggers, 24/7 operation), multi-modal communication (SMS, email, Slack, voice calls), conversational configuration, multi-agent collaboration, dynamic apps and scripts, and enterprise security and governance. Example use cases include cross-platform automation (“dig through last week’s Slack messages and create a Notion overview doc”), scheduled monitoring (“every morning, check my HubSpot todos and ping me on Slack if something is urgent”), and bulk data processing across spreadsheets and integrations. Full page →What is an AI agent?
An Abundly agent is a multilingual, autonomous digital colleague — faster and cheaper than humans, more intelligent and flexible than code, sitting in between. Agents are designed to augment humans by handling routine knowledge work that involves fuzzy inputs, uncertainty, and judgment, freeing people for strategic tasks. Every agent has four components: an LLM (Claude, GPT, Gemini, or others) as its brain, a Mission (natural-language instructions that are versioned and can be self-updated), Tools (grouped into capabilities like Slack, Gmail, code execution, web search, and 40+ integrations), and Autonomy (schedules, triggers, and proactive communication). Benefits over manual work include lower cost, higher speed, better control through written instructions, and higher consistency. Full page →Getting started
Sign up at app.abundly.ai for a free trial with credits — no credit card required. Create an agent from scratch or clone one from the Agent Catalogue. Configure your agent by chatting with it (it writes its own instructions from the conversation), enable the capabilities it needs, then test and refine. Full page →Platform overview
When you log in, you land on the Workspace page — your home base, showing every agent in your workspace as cards in a Starred section and an All agents section grouped by team, each with an A–Z / Recent first sort toggle, plus tag filters, name search, and a + New agent button. The left sidebar gives access to workspace-level features: Workspace (members and invitations, shared documents, and — for Creators and Admins — the Secrets and Outgoing APIs your agents use to reach external services; Admins also find workspace settings, model selection, data processors, and API keys here), Management (Agent management for security and access controls, and Usage & Limits for credit monitoring and spending limits), and Help & support. The Agent page is where you configure, monitor, and interact with an individual agent — an agent selector switches between agents (with a search box once the workspace has six or more), and the sidebar includes Instructions, Docs, Capabilities, Activity, and Settings, organized in tabs: main settings (name, avatar, description, email address, chat settings, daily credit limits, and turning the agent on or off, cloning, exporting, or deleting it), Value, User access, Agent-to-Agent Communication, Model Selection (default model, backup model, and per-context model and effort settings), Public sharing, and API Access as an HTTP API, MCP server, webhook receiver, or chat widget. The chat interface supports text, voice input, file uploads, and Walk & Talk mode, and its top bar has a per-chat model picker, a Show details toggle for the agent’s tool use and reasoning, and an Effort setting (Faster, Balanced, or Smarter) that controls how deeply the model reasons before responding. Your profile image at the bottom left opens the account menu: personal settings, My chats (your own chats with every agent across all your workspaces), workspace switching, and sign out. Full page →Pricing
Abundly uses a credit-based pricing model: you pay for credits consumed when agents perform actions. You can create unlimited agents, while workspace member seats depend on your plan — see app.abundly.ai/prices for current plans and credit allotments. Each subscription includes a monthly credit allotment that refills at the start of every billing period and doesn’t carry over, while top-up credits stay on your account until used. During the trial, exposing an agent through API access (HTTP API, Document API, MCP, chat widget, or webhooks), the most expensive models (such as Fable), and the Virtual Machine capability require a paid plan; all other models and capabilities are available, and the locked features unlock automatically when you upgrade. You can set per-agent spending limits and track usage through the Usage Reports dashboard. Full page →Features
Agent Instructions
Instructions are your agent’s job description in natural language, a working agreement between the agent and its owner that is included in every chat, trigger, and scheduled run. You can edit them directly, or describe the job in chat and let the agent draft its own instructions for your approval; the agent often writes clearer instructions than people do and tells you which capabilities and documents it needs. The Update Instructions capability is on by default with two guardrails, Chat only (no updates from Slack, Teams, or autonomous triggers) and Edit access required, and documents that carry behaviour, such as a script or checklist, can be held to the same standard by marking them Protected. Every change is versioned automatically, so you can compare versions side by side, see whether you or the agent made a change, approve or undo individual changes, and restore any earlier version. Full page →Configurable Capabilities
A capability is a feature or integration your agent can use: platform features such as image generation, code execution, or document editing, external integrations such as Slack, Google Drive, HubSpot, and GitHub, plus Outgoing APIs, custom MCP servers, and Skills, each on its own tab of the agent’s capabilities page. Too few capabilities and the agent can’t do the job, too many and it gets confused about which to use, so start small; if the agent needs something that isn’t enabled, it shows a capability card in the conversation so you can switch it on without leaving the chat. Capabilities blocked by an admin, whether workspace-wide, for your team, or for personal agents, stay visible as greyed-out Disabled by admin cards that explain why when clicked, and category badges show an available/total count where restrictions apply. Workspace and team admins can attach extra instructions to a capability (house rules such as which Slack channels to prefer; team text replaces workspace text), set a default or a lock on a curated set of guardrails and approval rules, and choose which capabilities new agents created from scratch start with. Extra instructions are guidance for the agent, while locked settings are enforced on every agent and can’t be changed per agent. Full page →Skills
A skill is a reusable guide that tells your agent how to do one kind of task well, such as building a spreadsheet in the virtual machine, writing in your brand voice, or compiling the monthly report your team’s way. The agent sees only a one-line catalog of its skills and loads the full guide when a task calls for it, so long procedures don’t crowd its instructions or cost tokens on every turn. Skills use the open Agent Skills format (a folder with aSKILL.md plus optional supporting files, the same format Claude uses), and the Skills tab lists built-in skills, some general and some that come with a capability such as the virtual machine or Slack, alongside the skills added to this agent, each with an on/off switch. You can add a skill from a GitHub folder or file URL, upload a .skill or .zip archive, write one in the document editor, or let the agent write its own; added skills are ordinary agent documents in a top-level skills folder, with version history, protection, and visibility controls (hiding a skill turns it off), and a skill named like a built-in replaces it for that agent. Skills are per agent, and a third-party skill is a set of instructions the agent will follow, so review it before adding it.
Full page →
Multi-channel Communication
Your agent isn’t stuck in a chat window: it can receive a request by email, update you on Slack, and call you when something is urgent. Chat is always available and is the only channel on by default as a security measure; email is built in and toggleable, SMS and voice calls are in beta and enabled by support, and WhatsApp, Slack, Teams, and other collaboration tools need their integration set up. With several channels enabled the agent makes a best guess, so guide it in its instructions (“always email me weekly reports”, “only call me for urgent issues”). Beyond text, agents work with images, audio, documents, and diagrams, and the Text to Speech capability, powered by ElevenLabs and OpenAI and charged per character, generates voiceovers to embed in emails, documents, and messages, for example a daily briefing to listen to while driving or an audio executive summary in a weekly email report. Full page →Advanced Chat
Each agent has a feature-rich chat similar to ChatGPT or Claude, though it is just one of the agent’s channels, used heavily during setup and tuning and to a varying degree afterwards. Each conversation is its own local context (its messages plus the agent’s instructions, documents, and capabilities), so anything that should outlive the chat must be saved to instructions or a document, with diary entries as the exception; a context indicator shows how full the conversation is (and, with Credit details on, what it has cost), and New chat with summary or Summarize for new chat carries a handoff recap, a short abridged copy of recent messages, and attached documents into a fresh chat. The chat supports file uploads (text files such as CSV, JSON, or logs up to about 15 MB), voice input, text-to-speech, editing sent messages, mid-conversation model switching, multi-user conversations with live-streamed responses, Duplicate chat (which also turns a Slack, Teams, WhatsApp, Google Chat, or chat-widget thread into a regular portal chat), and Export chat as markdown. History is saved automatically with participants shown per chat, a filter for all, my chats, or starred chats, and a list view for search and bulk management, while My chats in your profile menu lists your own chats across all agents in all your workspaces. Rich output such as HTML pages, React apps, charts, diagrams, and images opens as chat documents in a side panel that you can promote to permanent agent documents, the panel also browses the agent, team, and workspace libraries, and the agent can run code in chat when Code Execution is enabled. Full page →Email & SMS
Every agent gets its own email address (for examplemyagent.myworkspace@agent.abundly.ai, or a tenant-specific domain on dedicated enterprise deployments) and never touches your own inbox unless you enable a capability for that. Toggle Send Email and Receive Email with no further setup; Send SMS and Receive SMS work the same way but are enabled by support, and inbound SMS needs a dedicated number. Agents handle attachments, CC/BCC, replies, forwards, and rich HTML much like a person would, incoming messages need guidance in the instructions or the agent will likely ignore them, and the platform keeps every sent and received message for review under Activity (logging can be paused per agent). Guardrails restrict the agent to an allowed list of addresses or whole domains, with the owner pre-seeded as the only entry when Send Email is first enabled, and separate rules for recipients inside the list (send, or ask for approval) and outside it (block, or ask for approval); by default the agent emails allowed recipients freely and asks before emailing anyone else, and the same rules cover agents sending from a connected Gmail, Outlook, or Microsoft 365 mailbox once Allow sending email is on. Approval requests appear in chat or under Activity for triggers, with a Notify agent checkbox to tell the agent the outcome; start restrictive and loosen as you gain confidence.
Full page →
Voice Communication and Live Voice
Voice lets you talk to your agent and hear it answer, in four ways. The microphone button transcribes speech in most languages (with a microphone picker, and an editable transcript you can add to before sending), and the speak button reads any message aloud in the agent’s voice, chosen under Settings → Basic Information → Voice from OpenAI and ElevenLabs premade, professional, and cloned voices (ElevenLabs costs about five times as much per character, and voices from a provider your workspace has declined as a data processor can’t be used). Walk & Talk is a mostly hands-free, turn-based chat for walking or driving that keeps the agent’s full intelligence, while Live voice is a real-time spoken conversation in the browser: the agent answers within about a second, can be interrupted, uses its capabilities, can show documents or capability cards in a side panel, offers hands-free, push-to-talk, and toggle modes, and saves the transcript as a normal chat you can continue in text. Phone calls (beta) let anyone call your agent and your agent call anyone, with per-call settings for available capabilities, custom instructions (inline or from a document), voice, language and turn detection, Stable or Latest realtime model, an escalation number for transfers, allowed numbers for outgoing and incoming calls, and approval. Live voice and phone calls run on a realtime voice model rather than the agent’s configured model, trading reasoning for speed, so use chat or Walk & Talk for complex tasks, and on calls use the receptionist pattern: capture and confirm the request, then let a “phone call ended” trigger with the full transcript do the heavy lifting afterwards. Because the voice sounds human, instruct your agent to present itself as an AI. Full page → · Full page →Agent Documents
Documents are first-class storage: the workspace, each team, and each agent have their own library with full version history, and an agent reads across all three while by default creating and editing only in its own, unless workspace or team admins grant agents edit access to their libraries. Documents can be plain content, Interactive Apps, or Agent Databases; Markdown, code, and SVG are stored as editable text, PDFs, Office and Apple iWork files are transcribed with originals kept, images get vision descriptions, and audio and video are transcribed in the background with speaker labels and timestamps (plus Identify speakers and Re-transcribe), with a single document capped at about 15 MB of text. Each document’s agent visibility is Full (always in context), Summary (the default; the agent reads it on demand), or Hidden (only people can set it, and hiding a folder hides everything in it), while marking an agent document or folder Protected makes it read-only for the agent unless someone with Edit access is in the chat, so scheduled runs, incoming email, Slack conversations, colleagues with only Use access, and the public document API can’t rewrite a script or checklist that shapes its behaviour. Publishing creates links that need no account (with read/create/update/delete permissions for databases, Copy to my agent, and optional download of the original), and workspace admins choose who published documents are for: anyone, only people signing in with your Microsoft work account on enterprise SSO instances, or no one, which takes published documents offline until publishing is turned back on. Other features include direct links that open a document or app fullscreen, nested folders, drag-and-drop moves between scopes, library search, precise edits and exact, full-text, or semantic search by the agent, Chat about this for a document or folder, a Chat start document that opens in every new chat, rich-text copy, and downloads as text,.docx, PDF, originals, or ZIP; agent documents are stored in EU data centers in Stockholm, while external files such as Google Drive or SharePoint stay with their provider.
Full page →
Agent Databases
Agent databases (also called data documents) are special agent documents that store JSON records, like a lightweight MongoDB collection, created instantly with no setup (“create a database to track processed invoices”). Use one when you have many items of the same type, such as invoices, tickets, or products, and a text document for prose; the agent can convert between the two if you change your mind. The agent inserts, updates, deletes, and queries records from natural language, using direct queries for exact field matches and RAG-powered semantic search to find records by meaning, and databases pair naturally with interactive apps and scripts for dashboards, forms, and automation. Schemas are written automatically in TypeScript and the agent can change one and migrate existing records in one step; you can view data as a table or cards, import or export JSON, and publish databases with chosen permissions. For millions of records, joins, or data shared with other systems, connect an external database such as PostgreSQL or MongoDB via MCP, and move large spreadsheets (1,000+ cells) into a database rather than editing them cell by cell. Full page →Interactive Apps
Apps are agent documents containing code that renders as a user interface, such as dashboards, forms, calculators, and data browsers, built by asking (“create a dashboard for our OKRs”) and refined by you or the agent. React apps come with Chakra UI, Recharts, and Lucide icons, while HTML apps suit custom layouts, 3D, and maps; both run in a sandboxed iframe and can read and write agent databases, load other documents and the agent’s files as raw data, use public CDN libraries, generate downloads such as Excel, Word, or ZIP, and call a curated set of agent tools such as HTTP requests through an Outgoing API, BigQuery, Snowflake, or Notion. Larger apps can be split into a folder with anindex.html, index.jsx, or index.tsx entry file that gets a Run app button in any scope, and an open app can go fullscreen with a Chat button for asking the agent to change it, or be bookmarked as a start page. Apps start as chat documents in a resizable side panel and can be promoted to agent, team, or workspace documents for reuse and publishing; a published app needs its databases published too, which exposes their entire contents regardless of the operations you allow, and apps that call agent tools don’t work on public links. A TV production company used this to have an agent build its own database and scheduling dashboard for photographers.
Full page →
Code Execution
With Code Execution enabled, your agent writes and runs JavaScript on the fly in chat, or saves it as scripts, which are agent documents with version history. Code is faster, cheaper, and more reliable than token-by-token reasoning for large data, precise calculations, format conversions, and batch operations (analysing 500 feedback records might take 5 minutes and 0.01 by script), while the agent still uses its intelligence to write the code. Scripts can use all of the agent’s capabilities, such as web search, email, databases, and external APIs, with nested tool calls shown under the parent in the activity log, which enables workflows like weekly customer enrichment or competitive monitoring. Scripts can also be linked directly to scheduled tasks, webhooks, HTTP API endpoints, and MCP tools, running without any LLM call, and hand off to the full agent by returning{ escalate: true, message: "..." }; escalated runs get attack detection only if the script opts in with attackDetection: true, which it should whenever the message includes external content. A script run gets up to 256 MB of memory and can run as long as it keeps yielding, but code that blocks synchronously for more than two minutes is terminated.
Full page →
Virtual Machine
The Virtual Machine capability (paid plans only) gives your agent an ephemeral Linux VM with bash, Python, and Node.js, for when in-chat code execution isn’t enough. The agent creates a VM, runs commands, moves files in and out from chat attachments or agent documents (streamed, with no separate size cap), and reuses the same VM across steps so files and installed packages persist, waking it automatically if it has stopped. Typical uses are creating and editing.xlsx, .pptx, .docx, and .pdf files, processing large CSV, JSON, or Parquet data with pandas, browser automation with pre-installed Playwright, high-quality PDFs from Typst, package installs, and long multi-step jobs; for quick calculations, Code Execution is the lighter choice. Virtual Machine secrets such as GitHub tokens or API keys are substituted server-side into outbound HTTPS requests to the hosts you allow, so the agent and the VM only ever see a placeholder.
Full page →
Scheduled Tasks
Scheduled tasks let your agent work proactively by setting its own alarm clock. Recurring tasks (daily, weekly, monthly, or any pattern) live in the agent’s instructions, so saving the instructions creates or updates them, and if that fails the owners are notified and Sync from instructions retries; one-off tasks (“remind me to call the client at 3pm”) are scheduled through chat and disappear after running. Under Agent Instructions → Scheduled Tasks you can enable or disable tasks, see their details, and Run now to test one immediately, and a disabled agent runs no scheduled tasks at all. A task can be linked directly to a script for fast, deterministic work with no LLM call, and each task can override the agent’s model and effort setting. When a task runs, the agent has its instructions, capabilities, the task description, and its documents, so keep the task brief and put detailed guidance in a document; times without an explicit time zone use the agent’s configured time zone. Full page →Context and Memory
What your agent knows at any moment determines how it responds. Global context, meaning its instructions and agent documents (subject to visibility), is always available, while local context belongs to each interaction: a chat knows its own messages but not other chats, and a trigger sees its own details (for a Slack message, the five previous messages in the channel) but no chats. Memory across contexts comes from the agent reading and writing its own instructions and documents, so you can tell it to store preferences, decisions, and accumulated knowledge (“create a database to store everyone’s preferences and check them before communicating”), and it can read its own diary when asked. For accumulating facts and avoiding repeats, such as news items already sent, use agent databases with semantic search, which recognises when two items mean the same thing even if worded differently. The legacy Memory capability can no longer be added to new agents but keeps working where it is already enabled. Full page →Web Search, Scraping, Deep Research, and Docs
Four built-in capabilities, with no API keys needed, give agents information beyond their training data. Web Search (Perplexity) returns results with citation URLs in seconds for quick facts and current news; Web Scraping (Firecrawl) reads specific public pages for exact, live content and can take an extraction prompt so only the relevant part comes back; Deep Research runs a thorough multi-source analysis over 10+ minutes and uses significantly more credits, so it suits high-value strategic work; and Abundly Docs searches the Abundly documentation. Web Search, Web Scraping, and Abundly Docs are on by default, and Deep Research is opt-in. The agent usually picks the right one, but you can steer it: search is good for finding things, scraping for reading a known page accurately, and verifiable citations reduce the risk of hallucination. Full page →Multi-Agent Collaboration and Task Delegation
Agents can collaborate in two ways. Delegation spins up a temporary sub-agent with a task, chosen capabilities, optional documents, and optionally a cheaper model, mainly for context management and parallel work: an agent checking a contract against three standards can give each standard to its own sub-agent and keep its own context clean, and sub-agents with Edit Documents can write their findings to a document. Delegate Task is on by default, sub-agents can’t delegate further, and their work shows live in chat as a collapsible accordion. Agent-to-agent communication connects persistent, fully configured agents, such as a Twitter expert or a reusable ICP checker, set up under Settings → Agent Communication with Discoverability for inbound calls (No one, Team as the default, or Everyone) and explicit outbound connections that can also be added from chat; callers see only the target’s name and description, can share documents with read or read-write access, and with lifecycle phases only reach agents in the same phase. Agent-to-agent calls add cost and can give indirect access to another agent’s sensitive data, so connect deliberately, and consider task documents in a single agent first; for systems outside Abundly, agents call out via MCP or HTTP and can be called via API access. Full page →Model Selection
Every agent has a selected model: new agents start with the workspace default model if an admin has set one, otherwise the Abundly default, and changing a default later only affects new agents, so existing agents never change model or cost without someone choosing it. Most workspaces include Anthropic Claude (Fable, Opus, Sonnet, Haiku), OpenAI GPT (Astra, Sol, Terra, Luna), Google Gemini (Pro, Flash, Flash Lite), and xAI Grok, with optional EU-hosted families such as Qwen, Mistral, and GLM; the picker shows a one-to-six dollar-sign cost indicator and an EU-flag or globe marker for where prompts are processed, the most expensive models need a paid plan, and the reliable way to compare models across providers is to test on your own work or with agent evals. You can choose a Best alias that moves to newer verified versions or lock a specific version, set overrides under Settings → Model Selection per context (chat, scheduled tasks, incoming email, Slack, Teams, Google Chat, agent-to-agent), per scheduled task, and per chat, and tune thinking with an Effort setting of Faster, Balanced, or Smarter at each level. An opt-in backup model retries trigger runs (never chat) when the primary model is unavailable for the foreseeable future, and is off by default because a model from another provider makes the agent less predictable. Under Workspace management → Model selection, admins enable or disable models, set the workspace default, and choose whether new catalog models are on by default or need approval, in which case an alias only works while its current target is enabled; an agent whose model is disabled stops with a clear error rather than silently switching. Full page →Agent Personalization
Personalization makes agents feel like teammates rather than generic tools. Profile pictures can be auto-generated from the agent’s name and description, generated from your own prompt, uploaded, or left to Surprise me, and personality comes from instructions: a single sentence such as “be brief and to-the-point” or “communicate like the butler Jeeves” changes how responses feel, and tone can vary by context (polished HTML in email, brief in Slack). Chat Start Mode is Silent (the default), Fixed (the same opener every time), or Auto (a contextual greeting), while descriptions and tags organize agents, and descriptions are what other agents see in multi-agent communication. With the Update Agent Settings capability, on by default with the same Chat only and Edit access required guardrails as Update Instructions, agents can change their own name, picture, description, chat start mode and document, and value statement and key metrics when you ask. Agents shouldn’t pretend to be human, but a bit of personality makes them easier to work with, and it shows in their diary entries too. Full page →Agent Evals
Agent Evals let you define “working correctly” once and verify it automatically after any change, to catch regressions, compare models, and iterate with confidence. Each eval has a test prompt (run in Chat or Trigger mode, on a temporary clone by default, optionally without the agent’s system prompt for raw model benchmarks), optional tool overrides that exclude a tool or fake it with a canned response to prevent side effects or control inputs (including MCP tools, while calls that need approval never run), optional validation rules that fail fast on whether a tool was or wasn’t called, and an optional grader. The grader is either a grader model (Pass/Fail or Rating 1-10, seeing the full transcript or only the final response) or one of the agent’s scripts, which costs no credits, can’t call tools, and suits exact checks such as totals or valid JSON; write deterministic grader prompts that include the expected answer. You can run single evals or Run All across several eval models, including one model at different effort levels, see results by run in list and grid views with errors counted separately from fails and credits split between test and grader, inspect nested sub-agent transcripts, and export or import evals as JSON. The Evals capability lets the agent create, run, and review its own evals, the basis of eval-driven development where you write the evals first and let the agent refine its instructions until they pass. Full page →Activity Monitoring
The agent’s Activity page shows what it does on its own: a Usage tab (what it delivered, how much it was used, and what it cost, open to anyone who can use the agent), the diary, the activity log, saved messages, and owner notices. The diary is a readable record of activities and reasoning, written after triggers and significant chat moments while Write diary entries is on, and is the place to find out why the agent did something. The activity log is a live technical log of every trigger (chat excluded), filterable by event type, showing script execution, the pre-filter, attack detection for untrusted email and SMS (with blocked-attack alerts sent to recipients workspace admins choose), and execution with tool calls interleaved with the agent’s reasoning, nested calls, and per-phase and per-tool credits when Credit details is on. The Activity Log capability adds Chat about this on entries and lets the agent analyse its own trigger history and credit use, such as what a conversation has cost or which tool calls use the most credits (other chats only from the portal), optionally including Connected agent logs, while the Messages tab stores actual email and SMS content with a Save messages switch and audited per-row deletion. Owner notices give an agent a direct line to its owners through the always-availablenotify_owners tool, escalating to team and then workspace admins when there is no owner; admins can also send notices to many agents’ owners from Agent management, and every notice is listed under Activity → Owner notices with a Discuss with agent button.
Full page →
Usage & Limits
The Usage page has four tabs: Agent usage, Credit balance (workspace admins), Member adoption (active members, adoption rate, sessions per member, and new members, for workspace and team admins), and User action log (workspace admins). Agent usage is one row per agent showing what it delivered (criticality, value statement, and key metrics with trends), how much it was used, and what it cost over the last 7, 30, or 90 days, with filters for team, tag, criticality, key metrics, status (disabled agents hidden by default), lifecycle phase (production by default), and Owned by me, team subtotals, a bookmarkable URL, and a JSON Export in the Workspace API’s format; you see the agents you can use, team admins see all their teams’ agents, and workspace admins see everything. Personal agents are one Personal agents entry in the Team filter and one group, with each row saying whose it is, and are left out until you select them, and restricted and personal agents (default access Nothing) are listed for the admins who oversee them as figures only: the name is not a link and the key metrics don’t open. Credit balance shows the balance and next top-up, burn rate, credits used this period, balance history, and credits over time by agent or stacked by team, with CSV export. Agent limits on the Agent management page set a workspace-wide default daily limit (5,000 credits per agent per day for new workspaces) and per-agent overrides that only workspace admins and the agent’s team admins may change; an agent that hits its limit stops immediately until UTC midnight, with yellow badges at 80% and red when exceeded, and anyone with Edit or Owner access can Reset Today. Team monthly limits pause every agent in a team when its cap is reached, and personal agents draw on one monthly limit per person shared by all of that person’s personal agents (set under Workspace → Settings → Personal agents); monthly limits follow the calendar month in UTC, and everyone who can use an agent sees its monthly limit under Settings → Usage & Limits and as a chat banner at 80% and when it is reached, with workspace admins getting a link to edit it. Both LLM tokens and tool usage count toward credits regardless of trigger source, Credit details adds a sidebar widget with today’s usage, and the User action log is an append-only audit trail of changes to agents, teams, workspace settings, secrets, Outgoing APIs, and documents, with sensitive text shown as hash tokens, agent-made changes attributed to the agent, and CSV or JSONL export. Full page →Value tracking
Usage tells you what an agent cost; value tracking answers whether it is worth it. On each agent’s Settings → Value tab, the owner writes a value statement (what the agent does for you in your own words, where estimates like “saves about 10 hours a week” belong), sets a criticality (Critical, High, Medium, Low, or Not rated, the quickest way to sort a large fleet), and defines key metrics: concrete outcomes the agent records itself with the built-inrecord_key_metrics tool as they happen, such as Tickets created, Meeting summaries sent, or PRs merged. Each metric has a name, a description that serves as the recording rule, and optionally a measurement with a unit, and each record can carry a ref (such as a ticket id, so repeats update rather than duplicate) and a short note; the agent sees its value statement and metrics in its system prompt, while criticality is for people only. Bulk deletion of records always needs your approval, removing a metric hides its records without deleting them, and the agent can suggest metrics or write the value statement through Update Agent Settings, though recording never needs that capability. The figures appear on the agent’s Activity → Usage tab, the workspace Agent usage table, Agent management filters, Workspace and Team Explorer agents, and the Workspace API; since metrics are defined per agent, compare an agent with itself over time rather than ranking agents against each other.
Full page →
Workspace Members
The Members page is where workspace admins invite people and assign one of four roles: Admin (full control over members, billing, and capabilities, and oversight of every agent, restricted agents included), Creator (creates and uses agents according to agent-level settings), Collaborator (like Creator, but can’t create, clone, or import agents or manage workspace secrets and Outgoing APIs), or Guest (access only to agents they’re invited to from an agent’s User access tab, not counted toward the member cap). Invites take several addresses at once, optionally with names and direct team assignment, pending invitations count toward the cap and can be renewed or revoked, and admins can restrict membership and SSO auto-join to an allowed list of email domains. Every workspace keeps at least one Admin, rows show last login and last activity, members can leave a workspace (unless they are the last admin), and you can delete your account from Profile settings → Danger Zone with a 30-day grace period. The bell icon lists personal notifications such as approval requests, low-credit warnings, trigger problems, and owner notices from agents or admins, tuned under Profile settings → Notifications (email on by default, and a master switch that also covers future notification types), with admins able to set categories per agent, team, or workspace. Anyone holding the support role has workspace admin rights, counts as a member of every team, and is treated as an owner of the agents you grant them, even otherwise restricted ones; approving a support request with no agents selected grants every agent except restricted and personal ones, and grants expire on their own. Full page →Teams
Teams are an enterprise feature, enabled on request, that partition a workspace’s agents and people by department, project, or whatever fits, each with its own admins, capability settings, access controls, and document library. People can belong to several teams with team roles (Admin, Member, Guest) on top of their workspace role; team capability settings, edited on the Capabilities page, can only be stricter than the workspace’s (or turn on “default off” capabilities), with their own extra instructions, defaults, locks, and new-agent set, and Team Analytics and Team Explorer give team admins usage insight and read-only browsing of the team’s agents, except restricted and personal ones. Workspace admins create, rename, and delete teams (deleting one deletes its agents and shared documents) and set monthly credit limits, while team admins manage their team’s people from the team home page; an agent belongs to exactly one team, to no team as a global agent (whose creation the workspace allows for everyone, admins only, or nobody), or is personal, and a team agent can be offered to other teams or the whole workspace for chatting and triggering, never editing, from the Beyond panel under Settings → User access. Personal agents, which come with Teams and are switched on by workspace admins, let one person keep an agent of their own in the company workspace, such as an email assistant: only its single owner and the people they add by name under Settings → User access (with Use or Edit access, an executive’s assistant for example) can see and use it, it sits outside the shared teams, is reachable by default only from the owner’s other personal agents, and is listed under Personal agents on the Agents page. You create one by choosing Personal as the team when creating, importing, or cloning an agent, or an owner moves an existing agent with Move to team → Personal (other former owners keep Edit access), and a personal agent can be moved into a team the same way when others should use it. Workspace admins manage personal agents only from the outside: they see who owns one and who else has access, its description, value statement and key metrics, its capabilities and integrations, and its cost, and can disable, limit, change the model or lifecycle phase of, or delete it, but can’t read its instructions, chats, or documents, move it, or change its other settings, and team admins don’t see personal agents at all. Admins set a monthly credit limit per person shared by all their personal agents, a separate capability policy for personal agents (with switched-off capabilities, defaults, locks, and extra instructions), and per-agent daily limits under Agent Limits; Collaborators and Guests can’t have personal agents, and switching personal agents off stops new ones being created while existing ones keep working. Full page →Agent management
The Agent Management page gives workspace admins a table of every agent and team admins a table of their teams’ agents, to search, filter, sort, and update in bulk. Rows show the agent with a padlock for restricted and personal agents, a shield badge for admin-only agents, team and tag badges, today’s usage, last activity, last updated, and credit details, and expand to tags, enabled capabilities (including those disabled by admin policy), Outgoing APIs, MCP servers, message log status, owners and everyone else with access and their level, plus for workspace admins the description and instructions (only the description for a restricted or personal agent you’re not named on), agent-to-agent connections, and whether the agent is exposed through a widget, HTTP API, MCP server, or webhooks. Filters cover status, who can open the agent (only named people, everyone in its team, or everyone in the workspace, which includes team agents shared with the whole workspace), teams, tags, model, owner, capabilities, Outgoing APIs, MCP servers, value statement, criticality, key metrics, lifecycle phase, usage range, and last-activity and last-updated dates. Restricted agents (default access “Nothing”) and personal agents you’re not named on are seen from the outside, with who has access and at what level, the description, value statement and key metrics, capabilities and integrations, and cost; you can disable, limit, change the model or lifecycle phase of, or delete one but not read its instructions or trigger it, and on a restricted agent you can also change tags, move it, and choose who has access, including giving yourself access from the expanded row (logged in the agent’s activity log and the User action log), whereas a personal agent’s access and team stay with its owner. Bulk actions and each row’s menu follow the same order, configure, move, reach out, then stop or remove: change phase, set model, set daily limit, credit details, move to team, Trigger (one run with your message), Notify owners (bulk only, a notice marked as coming from you), enable, and disable, with the row menu adding open settings first and Delete last; Trigger skips disabled agents and restricted or personal agents you’re not named on, Move to team and credit details skip other people’s personal agents, and for an agent you can’t open the menu offers change phase, set model, set daily limit, enable, disable, move to team, and delete (someone else’s personal agent: the same minus move to team). Tags and access are edited in the expanded row, where Add under People with access gives someone Owner, Edit, or Use access and × removes it, and workspace admins can delete any agent and team admins their teams’ agents, including ones they can’t open, which removes its chats, documents, and activity for everyone. Moving agents between teams needs a say in both teams, as a workspace admin, an admin of both teams, or an owner who is a member of the target team, and the move dialog shows who will lose access; tags are free-text labels (trimmed, lowercase, up to 50 characters and 50 per agent, team, or member) shared with teams and workspace members. The Agent limits tab manages the default daily limit, per-agent overrides, and counter resets, and shows each agent’s owners (and whose a personal agent is), while capability policy lives on the Capabilities page and model availability under Workspace management → Model selection. An admin-only agent with Workspace Manager (paired with Workspace Explorer for reading) can do the same administration on request, including enabling or pausing agents, moving them, setting limits, model, criticality, credit details, and tags, and creating and renaming teams and changing their members, even on agents whose default access is “Nothing” that it can’t read; every change is logged under the agent’s name, and it can’t touch instructions, capabilities, access, credentials, or names, create or delete agents, pause itself, or delete teams. Full page →Agent lifecycle phases
Lifecycle phases separate the agents you are still building from the ones doing real work: every agent is either a sandbox agent or a production agent. Sandbox agents can’t use capabilities, secrets, or Outgoing APIs marked production only, use a secret’s sandbox value (a test credential) where one is set, talk only to other sandbox agents unless a production agent is Reachable from all phases, and pause when the workspace balance falls to the credit reserve kept for production. Nothing is restricted until you mark it, so turning phases on doesn’t change running agents, resources can also be marked sandbox only so a test system is never hit by a production agent, and a restricted sandbox agent explains the restriction and who can promote it. Promotion is direct by the roles you choose, or reviewed: an owner requests promotion, admin-defined review steps are each decided by any one of their reviewers, a single rejection rejects the request, and once every step approves the owner promotes, with workspace admins keeping a direct override and all requests listed on a Promotion requests page. Agents are promoted under Settings → Lifecycle phase, in bulk from Agent management, or by a Workspace Manager agent (never by an agent on itself), can be demoted without losing their configuration, wear a flask badge in the sandbox, and every phase change is audited; the feature is enabled per workspace on request and then switched on under Workspace → Settings → Agent lifecycle phases. Full page →Agent Sharing and Cloning
Cloning copies an agent within your workspace or to another workspace you belong to, which is useful for variations, templates, or per-team copies; if another team only needs to use the agent, share it instead. You can also Export an agent to a JSON file, optionally with documents, chats, evals and their results, and API access settings, and Import it as a new agent for backups or moving between environments. A clone copies the name, description, tags, picture, value statement, criticality and key metric definitions, instructions, capabilities, model, scheduled triggers, MCP servers (pending re-authentication), and daily limit, plus permission to use the workspace’s Outgoing APIs for same-workspace clones only; it never copies credentials, access settings, instruction history, public sharing, key metric records, or usage counters, chats come along only if you choose, API keys and webhook tokens are regenerated, and the person cloning becomes an Owner. Public sharing, an Owner-only setting, publishes a link that lets anyone clone the agent to their own workspace after seeing its name, description, creator, and instructions, optionally with its documents. Clones are fully independent, so updates to the original never reach them. Full page →HTTP Requests: Connect to Any API
The HTTP capability is your agent’s swiss army knife for any online service with an API: well-known APIs often work straight from training data, and others can be learned by experimenting, reading documentation, using Web Search, or your own description. It supports all standard methods over HTTPS on port 443 only, and refuses plainhttp://, internal network addresses, and URLs with credentials embedded; redirects are never followed automatically, so the agent decides whether to call the target and credentials are checked again. Two guardrails sit on the capability card: Allow requests to any URL (when off, only endpoint patterns of enabled Outgoing APIs are reachable) and Require Approval (No, Yes for all, or Yes except GET). For authenticated APIs, define an Outgoing API under Workspace → Outgoing APIs with URL-prefix endpoint patterns and keyholes describing what key is needed and where it goes, then pick which Secret fills each keyhole when enabling the API on an agent, so different agents can use different keys; keyholes cover bearer tokens, API key headers, basic auth, query parameters, custom headers, OAuth 2.0 client credentials, GCP service accounts, and signed JWTs, and the secret is injected server-side and never reaches the LLM. Secrets and Outgoing APIs each have an agent access setting (No one, Entire workspace, Certain teams, Certain agents) and optional lifecycle phase availability; the capability is enabled per workspace by support, and once a call works, ask the agent to “codify” it into its instructions.
Full page →
API Access
The API Access tab exposes your agent to external systems in five ways: an HTTP API for scripts and backend services, a Document API for reading and writing chosen documents and databases (never more than the agent itself could), an MCP server for AI apps like Claude Desktop, Cursor, and n8n, a Chat Widget for your website, and Webhooks for callbacks from services like Stripe, GitHub, or Trello. The first four use per-agent API keys with scopes limiting which surfaces each key may call, while webhooks rely on the URL as the secret with optional HMAC signature verification; workspace API keys (wk_..., part of the enterprise Workspace API) work on every agent that allows them. Each endpoint, MCP tool, or webhook gets a handler, either a natural-language prompt or a script that runs without the LLM, plus an optional model override, and browser calls to the HTTP API can be allowed through CORS settings. Webhooks answer 200 at once and process asynchronously (payloads up to 900 KB), while the HTTP API reports outcomes with status codes such as 429 for credit or concurrency limits, 422 for a model refusal, and 504 for a script timeout. API access needs a paid plan, every surface logs to the activity log and respects the agent’s capabilities and guardrails, and the Endpoint Management capability lets the agent manage its own exposed surfaces.
Full page →
Workspace API
The Workspace API gives external systems HTTP access to workspace data, including members, invites, teams, credits, secret metadata, capability and security settings, agents, tags, agent usage, promotion requests, and the user action log, plus each agent’s configuration, chats, documents, diary, activity log, messages, evals, connections, MCP servers, tool usage, key metrics, promotion history, and instruction history. Reads are backed by the Workspace Explorer capability and writes by Workspace Manager, so the same data and actions are available by asking an agent with those capabilities; writes cover enabling or pausing agents, model, daily limit, criticality, credit details, tags on agents, teams, and members, team moves (with a dry run showing who gains or loses access), lifecycle phase, and creating and renaming teams and changing their members, but not deleting teams. Agent writes are batchPOST calls with a result per id, so one bad id never fails the rest, unchanged writes are skipped in the audit log, and team endpoints act on one team or membership with standard status codes. It is an enterprise feature enabled per workspace, using wk_ keys whose Agent API endpoints, Workspace read API, and Workspace write API scopes are enabled independently, and every write is logged in the User action log under the user who created the key; the /action-log and /instruction-versions endpoints give the change history, for example to catch a production agent that drifted after its promotion was approved, with changed sensitive values shown only as redacted tokens. Secret values are always redacted, and restricted and personal agents (default access Nothing, access.customer of none, flagged isPrivate in the agent list) appear in the agent list and overview, usage and credit figures, the action log, and promotion requests, but every per-agent content read returns 403 except their promotion history, while writes can still target them as in the portal; promotion reviews can be read but never approved through the API, since a workspace key belongs to no one person.
Full page →
Chat Widget
The chat widget embeds your agent as a floating chat bubble on any website, where visitors get streamed answers with markdown and images without leaving the page or needing an Abundly account, typically behind your own login on a customer portal, internal dashboard, or help center. The widget never talks to Abundly directly: a small proxy on your backend holds anak_... key with only the Chat Widget scope and forwards three routes (/status, /chat, /images) server-to-server, so the key never reaches the browser and you can protect the proxy with your existing authentication. You can use the ready-made mountChatWidget bubble (via one script tag or the @abundly/widget npm package, with text and color options, a processing indicator, mobile layout, and rate-limit handling) or the headless createClient to build your own UI on the same streaming engine. On the agent you choose exactly which capabilities, Outgoing APIs, and MCP servers the widget may use, and can set a separate daily credit limit, dedicated widget instructions, a demo response, and a model override; the bubble stays hidden when the agent is unavailable or its limit is reached. Every widget message is screened by attack detection, conversations are stored as full chats in the portal, and the widget is enabled per workspace by support.
Full page →
Integrations
Integrations Overview
You give your agent access to external services like Slack, Google Drive, or GitHub by toggling capabilities on. Some capabilities use platform-provided credentials (Perplexity, send/receive email) and work out of the box; others need your own credentials through an OAuth button or API token field on the capability card, stored encrypted so the agent only reaches what you explicitly authorize. You don’t have to configure everything upfront — if you ask the agent to do something that needs a capability it lacks, it requests it by showing a capability card in the conversation. Some capabilities can be configured to require user approval, pausing the agent until you approve or reject the action. Agents come with a good default LLM, but you can switch to Claude, Gemini, or GPT models under the agent’s Settings → Model Selection. When no built-in integration fits, extend your agent with an MCP server or the HTTP capability. Full page →MCP Servers
MCP (Model Context Protocol) is an open standard for connecting AI applications to external tools, and you give your agent access to an MCP server from the MCP Servers tab — one click from the built-in library (Atlassian, Stripe, Sentry, Linear, and more) or by pasting an https:// URL. The platform detects whether authentication is needed, offers OAuth (recommended) or an API token, discovers the server’s tools, and lets you toggle them individually; an Advanced section handles non-standard setups such as custom authorization or token endpoints, your own OAuth client, scopes, vendor token headers, and extra headers, and Reauthenticate reuses those settings when a provider makes you sign in again. This lets you extend beyond built-in integrations, tap into community servers, or expose your own internal systems (CRM, inventory, custom databases) without waiting for platform updates. Only add servers from sources you trust — an MCP server can act on your behalf. Workspace admins can allow or disallow MCP servers for the whole workspace or per team with the Allow MCP Servers setting; when disallowed, servers already added to agents are disabled until MCP servers are allowed again. MCP credentials are encrypted with hybrid AES+RSA and OAuth tokens are never exposed to the model, and you can also go the other way and expose your Abundly agent as an MCP server that Claude Desktop, Cursor, or n8n can call as a tool. Full page →Integration pricing
Whether an integration consumes credits depends on whose credentials are used. With user-provided credentials (Slack, Notion, GitHub, Stripe, etc.) you already pay the provider, so Abundly doesn’t charge for the integration call — though any Abundly-side processing of what it fetched, such as extracting text from a file attachment, is billed like every other tool use. With platform-provided credentials (web search via Perplexity, image generation) Abundly pays the provider and converts the cost to credits charged to your account. LLM inference also consumes credits regardless of which integrations are involved. Credits are pooled across your entire workspace, so every agent and member draws from the same balance; you track consumption under Usage and Limits by agent or time period, and can set per-agent limits to cap spend. Full page →Anthropic
Anthropic provides the Claude family of language models, known for strong reasoning and safety features, with models optimized for everything from fast responses to complex reasoning. Claude is available as an LLM option for your agent under the agent’s Settings → Model Selection; see Model Selection for the full list and guidance. Full page →Atlassian
Connect your agent to Atlassian to work across Jira, Confluence, and other Atlassian Cloud products — searching issues, creating pages, and managing projects. The recommended route is the Rovo MCP server, added from the MCP Servers tab: an Atlassian organization admin allows Abundly once, then each user authenticates with their own account via OAuth (API-token auth on the MCP server exposes only a limited subset of tools). Alternatively, give the agent direct Jira and Confluence REST access with an Atlassian API token stored as a workspace secret and defined as an Outgoing API — useful when the admin can’t allow the domain, the agent should act as its own dedicated account, or you need endpoints the MCP server doesn’t expose; prefer a scoped token (called against a different base URL than a classic token), and remember tokens expire after at most a year. Use it for issue triage, sprint reporting to Slack, Jira-to-Confluence documentation sync, and cross-platform ticket lookups. Full page →Autodesk
Your agent can work with Autodesk Platform Services (APS) to upload CAD files, convert DWG drawings to DXF, PDF, or DWF, translate 3D models (e.g. RVT → IFC, DWG → SVF2), extract model properties and element hierarchies, generate standalone HTML 3D viewers, and call any Autodesk API endpoint. With APS app credentials alone (Client ID and Client Secret, the secret stored as a workspace secret, plus an EU or US region) it can upload, convert, translate, and view; after connecting an Autodesk account via OAuth it can also list ACC hubs and projects, browse folders, and download files from Autodesk Construction Cloud. Use it to convert drawings for clients, extract Revit door schedules, drill into mechanical systems, or pull the latest IFC from a Coordination folder. Full page →BigQuery
Your agent can explore your Google BigQuery datasets and run read-only SELECT queries on your behalf, so you get revenue breakdowns, scheduled reports, data-quality checks, and schema exploration without writing SQL. Queries have a 30-second timeout and a 1 GB billing limit, results come back with bytes processed so you can keep an eye on cost, and write operations and DDL are not supported. Authentication uses a GCP service account JSON key with the BigQuery Metadata Viewer, Data Viewer, and Job User roles, stored as team secrets. Full page →Cloud Storage
Your agent can list, read, write, and delete objects in any S3-compatible bucket — AWS S3, Cloudflare R2, Google Cloud Storage (HMAC), MinIO, Backblaze B2, or any provider that speaks the S3 API — with tools to list objects with pagination, inspect metadata, download, upload, and delete. Use it to archive email attachments, run scheduled CSV exports, fetch reference data like config files, clean up old objects, or summarize bucket exports into Slack. Downloads are limited to about 5 MiB and uploads to about 10 MiB per object; access keys are stored as a workspace secret, with an optional default bucket. Full page →ElevenLabs
ElevenLabs provides speech-to-text transcription and text-to-speech for your agent. All audio transcription uses ElevenLabs Scribe with no setup: the mic button turns dictation into clean text with filler words stripped, and uploaded audio or video recordings get speaker-labelled, timestamped transcripts; workspace admins can decline ElevenLabs under Workspace settings → Data processors, in which case transcription falls back to OpenAI Whisper (plain text, no speaker labels). ElevenLabs is also one of the providers in the Text to Speech capability, letting the agent generate voiceovers with a specific voice per request, and its premade, professional, and cloned voices appear alongside OpenAI voices as options for the agent’s own voice used by the Speak button and Walk & Talk mode. Full page →Figma
Connect your agent to Figma to inspect design files, render frames as images, browse team projects, list file versions, and read and post comments. Authentication uses a Figma personal access token with the scopes you choose, saved as a workspace secret; the agent can only reach files and projects the token’s owner can access, and because Figma’s API has no “list everything” endpoint you point it at a team ID or file key — paste a Figma URL in chat, or put a default in the agent’s instructions. Use it for daily design-comment digests to Slack, rendering a hero frame as a PNG, spec handoffs, audits of stale files, and comment triage. Full page →Firecrawl
Firecrawl powers your agent’s ability to read and extract content from web pages through the Web Scraping capability, which is enabled by default. Use it to summarize articles, extract pricing from product pages, or compare content across several URLs. For multi-source research, combine it with Perplexity — Perplexity finds the URLs, Firecrawl extracts the detail. Full page →Giphy
Giphy lets your agent search for and share animated GIFs, bundled into the Image Generation capability alongside AI image generation. Use it to add a celebration GIF to a team announcement, drop a thumbs up into a Slack post, or illustrate overall sentiment in a weekly report. Full page →GitHub
Connect your agent to GitHub to browse files, create and review pull requests, manage issues, and react when a pull request is opened. Authentication uses a personal access token (fine-grained recommended) stored as a workspace secret so other agents can reuse it and you rotate it in one place; list Watched repositories and add a repository webhook subscribed to the Pull requests event to have the agent triggered when a pull request is opened — without webhooks it still works whenever you ask via chat or scheduled tasks. Both GitHub Enterprise products (Enterprise Cloud with data residency and self-hosted Enterprise Server) are supported by entering your instance’s host name, with the token created on that instance; Enterprise IP allow lists need Abundly’s outbound IP, and a self-hosted instance must be reachable from the internet. Use it for code review assistance, release notes from commits, automated issue triage with labels, and dependency update PRs. Full page →Google Calendar
Connect your agent to Google Calendar to view events, schedule meetings, and block focus time. Authentication uses a personal access token tied to your Google account, and after connecting you choose which calendars the token can access — broad access or a least-privilege scope you can adjust later under Profile settings → Personal Tokens. When reading an event the agent also sees the Google Meet join link and conference entry points, plus file attachments such as Meet recordings, transcripts, and “Notes by Gemini” documents — as links only; reading their contents needs the Google Drive integration. The capability is currently hidden; email support@abundly.ai to enable it. Full page →Google Chat
Your agent can communicate with you and your team through Google Chat as its own named app: people @mention it in a space or direct-message it, and it replies with its full context, capabilities, and history, with each conversation mapped to a persistent chat that appears in the portal marked as “remote”. Each agent has its own Google Chat app (a classic HTTP Chat app, not a Workspace add-on) configured in your Google Cloud project, and two reply modes are selectable on the capability card: Direct reply (simple — replies returned in the webhook response, bounded by Google’s roughly 30-second timeout, and a top-level @mention’s reply starts a new thread) and API (advanced — replies posted via the Chat REST API using a service account key stored as a Google Chat secret, no time limit, replies land in the @mention’s thread, and the agent gets tools to post, reply, and direct-message in other spaces). DMs reach the agent on every message, spaces deliver only @mentions, and Chat apps can’t be added to multi-person group chats. Use it to kick off a research agent from a space, trigger a deployment agent, or hold a quick private back-and-forth with an assistant agent. Full page →Google Drive
Connect Google Drive with one of two capabilities: Google Drive (only specific files you share with the agent, plus files it creates) or Google Drive (Full Access) (all drives and folders you approve for the token, hidden by default — email support@abundly.ai to enable it). The file-scoped capability offers Personal mode (your own Google account via a personal access token) or Service account mode (a Google service account JSON key stored as a workspace secret; the agent reaches exactly what’s shared with the service account’s email, which is the way to cover a whole folder without Full Access, and it needs Content manager access on a Shared Drive to create files). Your agent can read Google Docs (whole document or a single tab), Sheets, Slides, text files, PDFs (including vision-based extraction of scanned or complex PDFs), common Office files, and Apple iWork files; edit Docs and Sheets; and create new Docs, Sheets, and Doc tabs. Use Reconnect to re-run consent if a token’s access has been revoked. Full page →Google Gemini
Google provides the Gemini family of language models and image generation. Gemini models are available as an alternative LLM under the agent’s Settings → Model Selection, and image generation uses Google’s gemini-3.1-flash-image model — toggle on the Image generation capability and select Google (new agents default to GPT for images, but Gemini remains fully supported). Use it to generate infographics from meeting notes or cover images for daily news summaries. Full page →HubSpot
Connect your agent to HubSpot to read and update any data in your CRM — contacts, companies, deals, tickets, tasks, emails, and custom objects. The agent can call any HubSpot REST API endpoint your token has access to, so anything you can do in HubSpot, the agent can do too. Authentication uses a private app access token with the scopes you choose (you must be a HubSpot super admin to create private apps). Use it for contact lookups, stuck-deal monitoring, company research, follow-up task creation, and ticket status updates. Full page →Meta Ads
Connect your agent to Meta’s Marketing API to analyse paid Facebook and Instagram advertising — ad accounts, campaigns, ad sets, ads, creatives, and insights — calling any Marketing API endpoint, so anything you can pull from Ads Manager, the agent can pull too. Authentication uses a system user access token stored together with your Meta App ID and App Secret in a workspace secret of type Meta Ads, reusable across agents and teams; Abundly refreshes 60-day tokens automatically and saves the new token back to the secret. The integration covers paid advertising only — not organic posts, Instagram content, Messenger, or WhatsApp. Use it for daily spend and CTR summaries to Slack, CPA anomaly alerts, weekly PDF reports, creative comparisons by ROAS, and account hygiene checks. Full page →Microsoft 365 Assistant
Connect your Microsoft account once and let an agent work across Microsoft 365 as you: read and draft Outlook mail, manage your calendar, browse, read, upload, and organize files in OneDrive and every SharePoint site you can see, and read your own Teams chats (1:1, group, and meeting chats — including going from a calendar meeting straight to its chat). It’s the simplest way to give an agent Microsoft 365 access; the separate Outlook, Outlook Calendar, and SharePoint capabilities remain for finer control or an agent running on its own identity. This is a personal connection — the agent acts as you, and anyone who can use the agent acts through your connection — so use it on agents only you have access to; Mail, Calendar, Files, and Teams chats toggle separately, and the sensitive Allow sending email (with the same recipient guardrails as the Send Email capability) and Allow deleting calendar events settings are off by default and can be locked by workspace admins. Teams is read only: the agent cannot post to Teams or see channel posts or meeting transcripts — for that, use the Microsoft Teams bot. All permissions are delegated Microsoft Graph scopes on a personal token you manage under Profile settings → Personal Tokens, and the capability is only offered when Microsoft OAuth is configured for your deployment. Use it for morning briefings, meeting prep from OneDrive and mail, filing invoice attachments to a SharePoint library, scheduling, and catching up on group chats. Full page →Microsoft Outlook
Connect your agent to Outlook to read and search your Microsoft 365 emails, download attachments as agent documents it can read, and draft or send email. Authentication uses a personal access token tied to your Microsoft work or school account (in many organizations a Microsoft admin must approve the Abundly Outlook app in Microsoft Entra first), and everything goes through the connected account’s own mailbox with delegated Microsoft Graph permissions, so the agent can never do more than you can. By default the agent can only save drafts; toggling Allow sending email turns the draft tool into a send tool with a Who can the agent email? section offering the same recipient guardrails as the Send Email capability — starting restricted to your own address, with approval required for anyone else — and it requires a token that holds the send permission, so an existing connection prompts you to reconnect. Calendar is a separate capability, and Microsoft 365 Assistant puts mail, calendar, OneDrive, and SharePoint behind one sign-in. Use it for inbox summaries, attachment search, daily digests to Slack, and SMS-driven follow-ups. Full page →Microsoft Outlook Calendar
Connect your agent to Outlook Calendar to manage the Microsoft 365 calendars you choose to share — a separate capability from Outlook email with its own personal access token, and after connecting you pick which calendars it may access (adjustable later under Profile settings → Personal Tokens). By default the agent can list calendars and read, create, and update events, including the Teams join URL; toggle Allow deleting calendar events to let it delete events or cancel meetings you organized (which notifies every attendee) — no reconnect needed. Permissions are delegated Microsoft Graph scopes, so the agent acts as you and can never do more than you can, and in many organizations a Microsoft admin must approve the Abundly Outlook app in Entra first. Use it for daily meeting briefings to Slack, scheduling from an email thread, and drafting post-meeting follow-ups. Full page →Microsoft SharePoint
Connect your agent to SharePoint to read, create, edit, and fully manage files and folders across your Microsoft 365 document libraries: browse sites and libraries, read file content (many Office and iWork formats), read site pages, news posts, and wiki pages as text, read and filter list items with their column schema, create and edit text files (txt, md, csv) in place, upload any stored file (Excel, Word, PDF, images) from agent documents, move, rename, copy, and delete (to the recoverable site recycle bin), and — opt-in — track what changed in one library or list since a window you choose. Documents, Pages, and Lists toggle separately on the capability card and are on by default, while Change tracking is off by default. Connect in Personal mode (a personal access token tied to your Microsoft account, then pick which sites and folders to allow) or App-only mode, where the agent runs as its own Entra identity with Sites.Selected (whole sites — the only option that also covers pages and lists) or Files.SelectedOperations.Selected (a single folder) permissions enforced by Microsoft; the client secret or certificate PEM is stored as a workspace secret, and a certificate is required for list-item attachments and comments. Office documents can be read, uploaded, and organized but not edited in place — to update one, have the agent generate a new version and upload it with overwrite. Use it for document search, handbook retrieval, intranet news digests, list tracking, weekly reports, delivering generated Excel files to a library, and saving Outlook invoices into a Finance folder. Full page →Microsoft Teams
Your agent can communicate with your team through Microsoft Teams as its own named bot: users @mention it in a channel to start a thread (follow-ups continue without re-mentioning), and every message reaches it in group chats and DMs, each mapped to a persistent “remote” chat with the agent’s full instructions, memory, and capabilities. Access is least-privilege by design through Resource-Specific Consent (RSC) — the agent reads only the teams and chats where its app has been added, enforced by Microsoft, and private and shared channels require the app to be added to that specific channel; a workspace can optionally grant tenant-wide Graph permissions for pre-install 1:1 history, reading private channels without per-channel adds, listing all teams, or user profile lookups. The agent sends images inline everywhere and, in 1:1 chats, files via a file card that uploads to your OneDrive (in groups and channels it uploads to SharePoint and shares a link when that capability is enabled), and it can read the transcript of a scheduled meeting it was added to — when the meeting ends it is triggered with the transcript, like an incoming email, to file it, mail a recap, or post decisions and action items in the meeting chat. Replies stream in 1:1 chats and carry Teams’ “AI generated” label,/compact starts a fresh chat with a summary, and you can tell the agent to leave a channel thread. Each agent needs its own Teams app, bot identity, and client secret; Abundly builds the app package for you, a Connection status section tests credentials and lists where the app is installed, and an admin-only agent with Microsoft 365 Admin can do most of the Microsoft-side setup. Use it for @Releaser deployments, @Researcher research, scheduled standup posts, and automatic post-meeting action items.
Full page →
Microsoft 365 Admin
The Microsoft 365 Admin capability lets a workspace admin hand Microsoft 365 setup work to an agent — granting an app registration access to a SharePoint site or folder, consenting permissions, registering Entra apps, minting client secrets, publishing and installing Teams apps — while keeping every action under their own approval and Microsoft account. The agent proposes an immutable plan of Graph requests as a card in the chat; you click Approve via Microsoft, consent to exactly those delegated permissions, and run the plan with a temporary token that acts as you, expires within about an hour with no refresh token, is bound to you, this agent, and this chat (scheduled triggers, incoming emails, and other agents cannot use it), and can be revoked early. Secrets a plan creates are written straight into Workspace → Secrets and replaced with a marker before the agent, the chat, or any log sees them, and every plan card also offers Run it yourself in PowerShell instead, which downloads the same plan as a script so no token of yours ever reaches Abundly. The capability needs no credentials, is only available on agents whose User access is set to Workspace admins only, and is currently enabled per workspace on request via support@abundly.ai. Full page →MongoDB
Your agent can run commands against your MongoDB database — finding documents, running aggregations, inserting records, and updating data — in plain English, translating your requests into MongoDB commands. What it can do is governed entirely by the database user in your connection string: a read-only user means the agent can only read, a read-write user also allows inserts, updates, and deletes. The connection string is stored as an encrypted workspace secret of type MongoDB reusable across agents and teams, an optional Default Database saves naming the database on every request, any MongoDB that accepts a standard connection string works (self-hosted, Atlas, or managed), and IP-restricted databases need Abundly’s outbound IP allowlisted. Use it for data questions, weekly order reports to Slack, maintaining records, exploring collections, and data checks. Full page →NetSuite
Connect your agent to NetSuite to read and update your ERP data — customers, vendors, invoices, sales orders, purchase orders, vendor bills, and any other record type — calling any NetSuite REST API endpoint and running SuiteQL queries (up to 5,000 rows per query) for reporting, joins, and aggregation, and running your existing saved searches and SuiteAnalytics Workbook datasets. Authentication uses the OAuth 2.0 client credentials flow with certificate authentication: the agent acts as a NetSuite integration mapped to a role you choose, so NetSuite enforces and audits everything under that role’s permissions, and your Account ID, Client ID, Certificate ID, and RSA private key live in a single workspace secret of type NetSuite reusable across agents and teams (map different certificates to different roles for separate privilege levels; sandbox and production need separate secrets). A Require approval setting (“Yes, for changes”, on by default for newly enabled agents and lockable by workspace admins) lets the agent read freely while every create, update or delete waits for a person’s approval. Use it for overdue-invoice monitoring, vendor bill triage against open purchase orders, SuiteQL sales reporting to Slack, and data hygiene. Full page →Notion
Connect your agent to Notion to read pages, query databases, search content, and create or update pages in your Notion workspace. Authentication uses an internal integration token with the read, update, and insert permissions you choose; the agent can only access pages you explicitly share with the integration (child pages inherit access) and cannot browse your whole Notion workspace. It can also upload files from agent documents — including Slack attachments and chat uploads — and attach them to pages. Use it for CRM-style database entries from forwarded emails, content search, meeting notes from Slack, overdue task summaries, and Slack-to-Notion file handoffs. Full page →OpenAI
OpenAI provides GPT models as an alternative LLM (under the agent’s Settings → Model Selection), image generation, text to speech, realtime voice, and image recognition for your agent. GPT image generation is the default provider for new agents — enable the Image generation capability and select GPT — with low, medium, or high quality levels (low is the default; high suits complex scenes and precise text or typography) and up to 16 source images for editing, compositing, or style transfer. OpenAI TTS reads any chat message aloud via the Speak button, and the Realtime API, combined with Twilio, powers the Make Phone Call and Receive Phone Call capabilities (currently hidden — contact support@abundly.ai to enable them). Image recognition lets the agent analyze screenshots, invoices, and charts supplied through chat, agent documents, or email attachments. Full page →Perplexity
Perplexity powers your agent’s web search and deep research as a platform-provided integration with no setup. Web Search (enabled by default) returns answers in seconds for quick facts, news, and lookups, while Deep Research takes much longer but delivers comprehensive analysis with extensive citations; the agent includes citation URLs in all responses. Use it for competitive analysis, daily news monitoring to Slack, due diligence on new leads, and market research with academic sources. Full page →Salesforce
Connect your agent to Salesforce to read and update any data in your CRM — contacts, accounts, opportunities, leads, cases, tasks, and custom objects — calling any Salesforce REST API endpoint including SOQL queries, so anything you can do in Salesforce, the agent can do too. Authentication uses an External Client App with the OAuth 2.0 Client Credentials Flow: the agent acts as a run-as user you choose (a dedicated API-only integration user is recommended), and your My Domain login URL, Consumer Key, and Consumer Secret live in a single workspace secret of type Salesforce reusable across agents and teams. The agent can also download files such as PDFs and attachments from Salesforce as agent documents. Use it for daily lead triage, stale-opportunity monitoring with follow-up tasks, account research, duplicate-contact hygiene, and custom-object summaries to Slack. Full page →Slack
Your agent communicates with you and your team in Slack with its own identity — its own Slack app, bot user, and token. People @mention it in a channel or DM it and it replies in the same thread with full context, capabilities, and history; follow-ups in a thread it joined, and replies to threads it started, continue the chat without re-mentioning, while other channel chatter is ignored, and you can tell it to leave a thread (it announces this first and an @mention brings it back — DMs and group DMs can’t be left). Chat mode (default) already covers proactive posting, DMs, reactions, and all Slack tools, while Trigger mode forwards each subscribed Slack event as a raw trigger payload for ambient monitoring or custom automations with no automatic reply — use it cautiously, since multiple Trigger-mode agents in one channel can spiral into a reply loop that burns credits. An optional Stream replies switch (off by default) shows replies as they are written with a progress card per tool and switches output to standard Markdown, and a Restrictions section can limit the agent to an allow-list of channels (names or IDs) and disable direct messages — enforced by the platform as a guardrail, not just an instruction. Beyond posting, reading, and reacting, the agent can call any Slack Web API method (pinning, bookmarks, user groups), and it can both download shared files into agent documents and send files back — agent documents, generated images, HTTPS URLs, and SVGs auto-converted to PNG. Setup uses an Abundly-generated app manifest with scopes, event subscriptions, and webhook URL pre-filled, and your Slack app’s signing secret is required so the platform can verify that events genuinely come from Slack; deleting an agent stops its Slack responses immediately and revokes the bot token once the deletion is permanent. Full page →Snowflake
Your agent can explore your Snowflake databases and run read-only queries so you get insights, reports, and data checks without writing SQL — no DDL or DML, and queries time out after 30 seconds. Authentication uses either a Snowflake Programmatic Access Token (PAT) or an RSA key pair — no password — together with your Account Identifier and Login Name (a dedicated service user works) in a single workspace secret reusable across agents and teams. Use it for revenue rankings, scheduled weekly signup summaries to Slack, cross-source reconciliation, schema discovery, and ad-hoc campaign analysis. Full page →Steep
Your agent can discover and query your Steep metrics in plain English, using the same shared definitions (MRR, conversion, etc.) your team already uses in Steep’s semantic layer, and returns aggregated data — plus the generated SQL when relevant — without opening a dashboard or writing SQL. Authentication uses a Steep API key stored as a team secret. Use it for metric lookups, scheduled KPI reports emailed to leadership, pulling metrics into Notion updates, trend analysis, and board-prep one-pagers. Full page →Trello
Connect your agent to Trello to manage cards, respond to board events, and automate your workflow. Authentication uses an API key, token, and one or more board IDs generated through a Trello Power-Up; configuring a board ID automatically subscribes the agent to that board’s events — card changes, comments, members, labels, checklists, attachments, and more — with a default set (card created, card moved between lists, comment added, label removed) you can customize and scope to specific lists in the capability settings, and you mention the events in the agent’s instructions so it knows what to do when they fire. Use it for inbox-list triage, comment auto-replies, weekly Done-list cleanup, and creating cards from incoming emails. Full page →Twilio
Twilio powers your agent’s SMS and phone call capabilities — Send SMS, Receive SMS, Make Phone Call, and Receive Phone Call — with phone calls combining Twilio and the OpenAI Realtime API for natural voice conversation. You can configure a whitelist of allowed phone numbers and require approval before sending messages or making calls. Use it for appointment reminders, SMS triage, outbound demo scheduling, and inbound support intake; Twilio-based capabilities are currently hidden — contact support@abundly.ai to enable them. Full page →Twitter / X
Connect your agent to Twitter/X with two separate capabilities: Twitter/X Search (search tweets, get user info, and analyze followers, using an API key from TwitterAPI.io) and Twitter/X Post (post tweets and replies from your account, using OAuth credentials from an X Developer app with read-and-write permissions — the X API Free tier has limited write access, so Basic or Pro may be required). Use it for brand-mention monitoring with sentiment summaries to Slack, competitor tracking into Notion, content publishing with approval workflows, community engagement, and lead research from new email contacts. Full page →Guides
Find your use case
Not every task benefits from an agent — some are better handled by code, others by humans. The sweet spot for agents lies in tasks that are routine and time-consuming, don’t require deep expertise or creativity, involve fuzzy inputs that pure code can’t handle, and carry correctable (not mission-critical) stakes. To find candidates, map how your team spends time along two axes: frequency/time investment and value of your time. Tasks that are frequent but feel like poor use of a human’s time are your best starting points. Good examples include screening incoming emails, generating weekly summaries from multiple sources, and reviewing documents against a checklist. Start with simple use cases to build intuition for how agents think and what context they need before tackling complex workflows. Full page →Agent design
Agent design is the process of figuring out what an agent should do, how it does its work, how success is measured, and how it interacts with humans and systems. The Agent Design Canvas is a framework covering ten aspects: Purpose, Triggers, Action Plan, Interfaces, Capabilities, Impact, Input, Knowledge & State, Output, and Success. The Action Plan is the heart of the design — numbered steps showing the workflow with clear human-AI handoffs. Apply the principle of least privilege when choosing capabilities, and define success in measurable business terms. Every agent needs a clearly defined human owner responsible for its behavior, analogous to an editor-in-chief who sets guardrails and follows up when things go wrong. Prototype early with fake data or simulated integrations — a useful first prototype can often be built in 30 minutes. Keep instructions clean by limiting context to what the agent actually needs, and plan for iteration: getting an agent from “works OK” to “awesome” typically takes a few rounds of refinement. Full page →Agent optimization
Every agent consumes credits when it works, with costs varying by task complexity and LLM choice. A simple news check might use around 50 credits, while screening 300 acquisition targets could use 5,000. To reduce costs, evaluate run frequency, trim context to essentials, store reference information in agent documents (with Summary visibility) rather than instructions, simplify instruction logic, and consider switching to a cheaper model if your use case allows it. In chat, the context indicator in the action bar shifts from gray through yellow, orange, and red as context grows — start a new chat when it gets high to keep responses fast and cheap. Use the Usage & Limits dashboard to track per-agent consumption and set daily limits to prevent runaway costs. Full page →Troubleshooting
Common issues fall into a few categories, and the first step is telling problems that clear up on their own from ones that need a change on your side. Provider errors differ by duration: “Overloaded” errors and short-term rate limits come from traffic spikes and are retried automatically (wait, or temporarily switch models), whereas Provider capacity limit reached means a daily or monthly account quota is exhausted — the run ends immediately, and you wait for the reset or switch model or provider. Chats that outgrow the model’s context window or the provider’s request-size cap (images and large files count heavily toward the latter) stay blocked whichever model you pick; continue with New chat with summary, or a plain new chat if even the summary is too large. A Request refused card means the model itself declined under its provider’s content rules, so resending gives the same result — rephrase with Edit or switch models (over HTTP the refusal returns status 422). Integration failures usually trace back to missing OAuth scopes, expired tokens, missing Slack channel invites, misconfigured webhooks, or external rate limits, and invalid verification codes result from requesting multiple codes — codes expire after 30 minutes and a successful sign-in invalidates remaining ones. To reach support from inside the app, open Help & support → Contact support for a structured message with your verified email as reply-to and optional context from your session, or email support@abundly.ai. Full page →Use Cases
Use Cases
Abundly publishes detailed use cases at abundly.ai/use-cases, each showing the challenge, solution, and results. Below is a categorized summary. Support & knowledge base:- HR Support Agent — Answers employee questions about policies and processes, escalates sensitive issues to HR colleagues, and keeps the knowledge base current.
- Helpdesk Agent — Handles incoming support questions with consistent answers, escalates complex issues with context, and learns from every interaction.
- Lead Generation Agent — Searches the web for companies matching your criteria, verifies relevance, and delivers contact details.
- Lead Analysis Agent — Researches incoming leads, scores them against your ideal customer profile, and alerts your team to high-potential opportunities.
- Sales Proposal Agent — Transcribes meeting notes, drafts tailored proposals, and formats everything to your company template.
- Commercial Contracts Agent — Organizes your contracts, answers questions about terms and pricing, and enables analysis across your entire contract portfolio.
- Procurement Agent — Reviews procurement documentation against standards, validates compliance, and flags contradictions.
- Target Screening Agent — Researches potential investment targets, scores them against your criteria, and surfaces the most promising opportunities.
- Security Vulnerability Agent — Monitors vulnerability disclosures, filters for relevance to your codebase, and alerts the right people.
- Product Updates Agent — Monitors your repository, translates commits into plain-language release notes, and posts them to Slack.
Security
Security Overview
Abundly agents can make decisions and act on your behalf, so the platform stacks four layers of protection. The LLM layer uses Claude from Anthropic by default (trained with Constitutional AI and safety-evaluated before each release), with OpenAI and Google models as alternatives. The platform layer adds an internal system prompt for responsible autonomous behaviour, attack detection on untrusted trigger content, code-enforced guardrails, and access controls. The agent layer limits each agent to its instructions and capabilities, so an agent without email access can’t send email no matter what it’s asked, and the user layer is you: choosing capabilities, configuring guardrails, requiring approval for sensitive actions, and monitoring what agents do. At a glance: EU-only data residency (Stockholm, Sweden), AES-256 at rest and TLS 1.2+ in transit, ISO 27001 certified and GDPR compliant, credentials never exposed to LLMs, complete audit trails of every agent action, and daily credit limits per agent to prevent runaway costs. Full page →Risk & Autonomy
Not all agents carry the same risk: a read-only internal research assistant is fundamentally different from a customer-facing agent that sends email and modifies databases, so security starts at design time by asking which capabilities and data the agent needs, who it talks to, and what could go wrong. Think of it like hiring an intern — most jobs don’t need the company bank account, and an intern with both customer data and email is a leak vector unless you split the roles or add safeguards like approval for external email or domain restrictions. Risk rises across five factors: scope, tools (read-only vs. write, send, call, delete), communication (internal vs. customer-facing), data access (public vs. confidential, PII, financial), and reversibility. A ticket-priority agent is safe essentially out of the box, while a customer-inquiry handler needs better models and instructions, more testing, guardrails, human-in-the-loop approval, closer monitoring, and gradual autonomy. Decision-making is a spectrum — agent decides, agent decides and informs human, agent suggests and waits for approval, agent asks human to decide — that you shift as the agent earns confidence, guided by the principles of Least Privilege and Earned Trust. Full page →Attack Detection
Attack detection screens incoming trigger content before the agent acts on it, protecting against manipulation — especially prompt injection through channels like email and SMS where anyone can send content to the agent. It runs in a separate context from the main agent and evaluates the raw trigger payload for prompt injection, data exfiltration, jailbreaks, and reconnaissance (probing what the agent has access to). It runs automatically for incoming emails and SMS, and for script escalations to the full agent that opt in withattackDetection: true; scheduled tasks, authenticated webhooks, and other controlled sources skip it. When an attack is detected, the agent doesn’t act, the block is logged to the activity log with the reasoning, alert emails go out, and a diary entry records it. Workspace admins configure alerts in Workspace → Settings: recipients (all workspace admins, admins plus extra addresses, or a custom list) and whether to include the blocked payload for debugging.
Full page →