Skills & Agent Tools

Agents in Aura Workshop don't answer from memory alone — they act. Roughly 105 built-in tools let an agent read and write files, run shell commands, search the web, generate media, recall knowledge, drive automation, spawn subagents, delegate to peers, and deploy to remote hosts. Skills sit on top: reusable, versioned capability packs the agent loads automatically to specialize its behaviour. You never call a tool by hand — you describe the outcome, and the agent classifies the task and pulls in exactly the tools it needs.

How this fits together. Tools are the raw verbs. Skills are curated recipes and instructions layered over those verbs. MCP servers add more tools at run time. Connected accounts (see Integrations) unlock the tools that act on third-party services.

The tool model

Every turn, the agent loop decides which tools to expose to the model based on the task's category and role configuration. Categories accumulate — once a task has earned access to, say, media tools, that access stays for the rest of the task. Tool results (including base64 images from vision tools) stream straight back into the transcript. Where a tool runs depends on the active isolation layer: bash, for example, can execute natively, inside a Docker container, over SSH, or in a Singularity image without the agent knowing the difference. See Deployment & Security for the isolation layers.

The tools below are the built-in registry. On top of them, any connected MCP server contributes its own tools at run time, and those appear to the agent exactly like native ones.

The tool catalog

Grouped by what they do. Tool names are stable identifiers you'll see in the transcript.

File & shell

Tool	What it does
`read_file`	Read a file's contents (text or base64-encoded binary).
`write_file`	Create or overwrite a file, creating parent directories as needed.
`edit_file`	Targeted find-and-replace edits — surgical changes without rewriting the whole file.
`glob`	Find files by glob pattern (e.g. `src/*/.ts`).
`grep`	Search file contents by regular expression, with paths and line numbers.
`list_dir`	List a directory's entries with types, sizes, and modification times.
`bash`	Run a shell command. Routes to native, Docker, SSH, or Singularity depending on the execution backend, and is subject to the safety guardrails below.

Web

Tool	What it does
`web_search`	Multi-engine web search through the bundled OpenSERP service; returns text results and image URLs.
`web_fetch`	Fetch and read a URL's content, for pages, data, and web APIs.

Media generation

Every media tool renders to a file the agent hands back inline in the transcript.

Tool	What it does
`generate_image`	Generate images from a text prompt via configured image APIs.
`generate_video`	Generate video from a prompt.
`generate_music`	Generate music and audio.
`generate_speech`	Text-to-speech synthesis.
`generate_lyrics`	Generate lyrics to pair with music generation.
`chart_generate`	Data visualizations rendered to PNG — a simple path (bar, line, pie, scatter, histogram, area) plus an advanced spec path for dozens of chart types.
`render_diagram`	Render diagrams (flowcharts, sequence, ER, class, and more) to an image file for embedding in reports.

Memory & knowledge

These read from and write to Aura's memory and knowledge stack. Recall is automatic at task start; these tools let the agent query and curate deliberately.

Tool	What it does
`platform_save_memory`	Store a durable fact for future recall.
`platform_recall_memory`	Search stored facts on demand.
`codegraph_query`	Query the lightweight code-symbol and import index across your repos.
`concept_query`	Traverse the LLM-built concept graph of entities and typed relationships.
`wiki_search` / `wiki_read` / `wiki_write`	Search, read, and author durable markdown wiki pages the agent maintains as a knowledge base.

Platform automation

The platform_* family lets an agent operate Aura itself — creating and managing the automation primitives covered in Automation & Workflows. There are roughly 60 of these; a representative slice:

Tool group	What it does
`platform_create_listener` · `_webhook` · `_schedule`	Stand up chat listeners, webhooks, and scheduled tasks programmatically (plus matching `edit`/`delete`/`start`/`stop` tools).
`platform_create_skill` · `_team` · `_workflow` · `_role`	Author new skills, teams, workflows, and agent roles; `platform_improve_role` refines an existing one.
`platform_run_workflow` · `platform_run_team_task`	Kick off a workflow run or a team task.
`platform_send_message` · `platform_message_agent` · `platform_search_conversations`	Send messages out through connected platforms, message other agents, and search prior conversations.
`platform_store_credential` · `platform_get_credential`	Read and write the encrypted credential store from within a task.
`platform_connect_mcp` · `platform_edit_mcp` · `platform_list_mcp`	Manage MCP server connections at run time.
`platform_get_settings` · `platform_update_settings`	Read and change application settings.

Subagents & inter-agent messaging

Tool	What it does
`platform_spawn_subagent`	Launch a child agent on a scoped sub-task.
`platform_check_subagent` · `platform_collect_subagents`	Poll a subagent's status and collect finished results.
`agent_list` · `agent_send` · `agent_history`	Discover running agents, send them a message, and read their history — the inter-agent registry. These are dispatchable helpers handled by the registry, not tools with a formal published schema.

ACP delegation

Delegate work to enabled ACP peers (other Aura instances or any ACP-compatible agent). Peers must be discovered and enabled first — see Multi-Agent Teams.

Tool	What it does
`delegate_to_acp_agent`	Pin a task to one specific peer.
`delegate_to_acp_pool`	Auto-route to a peer via a pool policy (best-fit / round-robin / random / lowest-load).
`delegate_to_acp_fanout`	Run the same task on all enabled peers in parallel.
`debate_acp_agents`	Run a multi-round debate across peers with an optional moderator.

Browser & desktop automation

Tool	What it does
`browser_action`	Drive a browser via the accessibility tree — navigate, click, type, and read pages.
`browser_act_run`	Run a stealth browser-automation flow for tasks that need a full engine.
`native_app`	Operate native macOS applications through the Accessibility API.

Docker & device

Tool	What it does
`docker_run` · `docker_list` · `docker_images`	Run a command in a container and enumerate containers and images on the host.
`system_notify`	Post a native desktop notification (macOS, Windows, Linux).
`screen_capture` · `camera_capture`	Capture the screen or webcam and hand the image to the vision tools.

Communication, deployment & meta

Tool	What it does
`email_send`	Send email via the system default or configured SMTP, with HTML, recipients, and attachments.
`deploy_remote`	Ship a containerized agent to a remote host over SSH — see Deployment & Security.
`run_chain`	Execute a chain script — a predefined sequence of tool calls packaged as a reusable recipe.
`role_complete`	Signal a role has finished in a team workflow, with structured handoff data for the next role.
`loop_continue`	Self-pacing control for autonomous loops — propose the next-wake delay from inside a cycle.

MCP tools. Tools from any connected MCP server are added to the agent's registry automatically and named after their server. Results are truncated to keep the context window healthy. Manage servers in Settings and via the platform_*_mcp tools above.

Command & tool safety

Tool execution runs through non-bypassable middleware. These protections are always active, regardless of settings.

Blocked shell patterns

Hard-coded destructive commands are refused before they ever run — for example:

Recursive root deletion: rm -rf /, rm -rf /*
Fork bombs: :(){ :|:& };:
Disk destruction: mkfs, dd if=/dev/zero, > /dev/sda
World-writable root: chmod -R 777 /

These stay blocked even when elevated (sudo) execution is enabled.

Timeouts & concurrency

Per-command timeout — a sensible default with a configurable ceiling; over-running commands are terminated automatically.
max_concurrent_tools (default 4) — caps how many tools run at once within a single task, so a burst of parallel calls can't exhaust the machine.
Loop detection — repeated identical tool calls are warned on and then hard-stopped, so an agent can't spin forever.

Isolation

Where bash and other tools actually run is governed by the execution backend and isolation settings — native, Docker-wrapped, SSH, Singularity, a host sandbox, or fully inside the daemon container. The blast radius of each layer, and what it does and doesn't defend against, is documented in Deployment & Security.

The skills system

Skills are reusable capability packs — ~106 ship bundled, and you can add your own. Each is a markdown file with YAML frontmatter (name, description, category, enabled, requires_connection, …) and a body of instructions, examples, and recipes. When a task looks relevant, the agent loads the matching skills automatically and follows them; you manage which are enabled in the Library / Skills UI.

Discovery order — project (.aura/skills/) → user (~/.aura/skills/) → bundled. A project or user skill of the same name wins.
Connections — a skill that needs an account declares requires_connection; connect that provider once (see Integrations) and the token is injected automatically at run time. Third-party service actions route through the connected integration rather than requiring you to paste API keys.
Curator — a background loop ages skills: active → stale after 30 days unused → archived after 90. Nothing is deleted; archived skills can be re-enabled.
Categories & descriptions — every skill declares a canonical category and a specific, single-purpose description, which is what lets the agent pick the right one.

Bundled skill categories

The bundled library is built around browser and desktop automation, document generation, and developer workflows — not per-service integration packs. Actions against third-party services (Slack, Gmail, GitHub, and the like) run through connected integrations (Composio / MCP), not bundled skills.

Area	What it covers
Browser automation	browser-act runner plus site scrapers for driving and extracting from the web.
Desktop assistant	Native desktop-app control — Chrome, Excel, Slack, Salesforce, SAP.
Document generation	DOCX, PDF, PPTX, and XLSX authoring; plus `weasyprint` for high-fidelity HTML-to-PDF and `pandoc` for format conversion.
Anthropic skills	skill-creator, mcp-builder, brand-guidelines, canvas-design.
Superpowers	Dev workflows — TDD, systematic debugging, writing plans.
Design & consulting	Design-quality and UX skills (excalidraw, typography), plus consulting and document-production helpers.

Skills describe how to use tools well; the tools do the work. Integration actions (Slack, Gmail, GitHub, etc.) run through connected integrations (Composio / MCP), and 195 role skills — markdown system prompts that reshape agent behaviour — are a separate system from these capability skills.

Role skills & authoring

Role skills are a separate system from capability skills. A role skill is a markdown system prompt with frontmatter (tools, model, max_turns, outputs) that reshapes how an agent behaves — you attach one to a task via the role picker in the composer, and it's the backbone of multi-agent teams. Sources resolve project → user → bundled, same as skills.

You can author both without leaving the app. Add a markdown file under .aura/skills/ (project) or ~/.aura/skills/ (user), or let an agent do it for you with platform_create_skill / platform_create_role. Because skills are just files with frontmatter, they version with your project and travel with it.

Where to go next: Automation & Workflows for the platform primitives these tools drive · Multi-Agent Teams for delegation and debate · Memory & Knowledge for the recall stack · Deployment & Security for isolation and remote agents · API Reference for the full command surface.