Table of Contents

πŸ‡«πŸ‡· Version franΓ§aise

See also: Creating a new tool Β· Back to index

Orkeon tool inventory

This page is the reference catalogue of the 124 built-in tool classes. The counting rule is the one scripts/check-doc-claims.py enforces: every *Tool.cs file under src/ except the interface (IBaseTool.cs) and the non-tool infrastructure that matches the glob (MockTool.cs, JsTool.cs, ObservedTool.cs, AIAgentTool.cs). The same script verifies that every tool name below exists in the code and every tool in the code is named below β€” this page cannot silently drift from the implementation.

The Tool column is the exact name agents and YAML tools: lists use (the contract's UniqueName). Which tools are actually available at runtime depends on the composition root β€” see Availability by composition root.

Collaboration and human-in-the-loop (Orkeon.Infrastructure)

Tool Class Registration Use case Call example
ask_question_to_coworker AskQuestionTool Built per agent by AgentDelegationToolsProvider when AllowDelegation is on β€” never in DI Ask a question to a specialized coworker agent { "question": "What is the Q4 revenue?", "coworker_role": "Financial Analyst", "context": "Fiscal year 2025" }
delegate_work_to_coworker DelegateWorkTool Same per-agent construction (optional AgentExecutionBudget for recursive depth control) Delegate a complete task to a specialized agent; with wait_for_result: true the coworker runs in the delegating task's context β€” same crew and memory scope, its answer never stored in the crew's memory β€” and outside a crew run the call is refused { "task": "Analyze competitor pricing", "coworker_role": "Market Researcher", "context": "Focus on SaaS B2B" }
spawn_agent SpawnAgentTool Not wired by any shipped composition root β€” a host registers it explicitly (IAgentFactory required) Create and execute a new specialised sub-agent at runtime (autonomous mode) { "role": "Fact checker", "goal": "Verify the claims", "task": "..." }
human_input HumanInputTool AddOrkeonHumanInput() β€” wired by orkeon run for a YAML crew (RunnerExecution) and by the REPL with its console provider; under --events the question surfaces on the run event stream, otherwise the default AutoApproveHumanInputProvider answers Ask the human a question (input_type: text, approval, choice with choices β€” recommended marks one option β€” or multi returning a list); headless, HumanInputOptions.HeadlessPolicy answers the default (Default) or refuses (Refuse); the runtime suspends until the answer arrives { "prompt": "Deploy to production?", "input_type": "approval" }

The display names of the first three contracts are prose (β€œAsk question to coworker”, β€œDelegate work to coworker”, β€œSpawn sub-agent”); the registry name β€” the one above β€” is what YAML references.

Search and knowledge tools (Orkeon.Infrastructure / Orkeon.Tools.Rag)

Tool Class Registration Use case Call example
semantic_search SearchTool AddSemanticSearchTool() (Orkeon.Hosting, opt-in β€” orkeon run calls it for a YAML crew) Embedding-based semantic search across memories { "query": "customer churn patterns", "top_k": 5 }
rag_search RagSearchTool AddOrkeonRag(config) + AddOrkeonRagTools() (Orkeon.Tools.Rag) β€” every runner host calls both RAG search in the collections rag_ingest filled (never the code index: codebase_search) over IRagPipeline. Typed result (answer, citations[]); structured question parameter (dataset for rag_eval) { "question": "What is our return policy?", "top_k": 3 }
rag_ingest RagIngestTool Same opt-in as rag_search Incremental ingestion into a RAG collection (manifest-driven β€” unchanged sources cost 0 embeddings) { "collection": "docs", "sources": ["/kb/**/*.md"], "reindex": false }
rag_eval RagEvalTool Same opt-in as rag_search Evaluate a collection against a golden YAML dataset: recall@k, precision@k, MRR, groundedness. Typed result (metrics[], cases[], reports) { "collection": "docs", "dataset": "/kb/eval/golden.yaml" }

Registered by every runner host. orkeon run (a YAML crew, a crew directory, a .ork.ts script) and orkeon-host register the RAG subsystem and its three tools, so a crew agent can list them in tools:; so do orkeon-repl and a C# host that calls AddOrkeonRag(configuration) + AddOrkeonRagTools(). The scripting facade (tools.ragSearch, the rag.* namespace) and orkeon rag reach the same pipelines. rag_search and rag_eval fall back to Orkeon:Rag:Collection when the call names no collection. See RAG pipeline.

Code execution tools (Orkeon.Infrastructure.Sandbox / Orkeon.Tools.Code)

Tool Class Registration Use case Call example
code_interpreter SecureCodeInterpreterTool AddOrkeonCodeSandbox() β€” concrete type only, not under IBaseTool: the registry cannot resolve it by name; a host injects or registers it explicitly Execute C# code in an isolated sandbox with static security analysis { "code": "return 2 + 2;", "timeout_seconds": 10 }
shell_command ShellCommandTool AddOrkeonCodeTools() β€” read-only allowlist by default (git limited to read-only subcommands); Orkeon:Tools:Shell:ExtraAllowedCommands adds commands, Orkeon:Tools:Shell:AllowedCommands replaces the list, Orkeon:Tools:Shell:AllowInterpreters = true opens interpreters and mutating git (one SECURITY line per host at the first call, stating the confinement in force); the process is confined by default (Orkeon:Tools:Shell:Confinement:Mode = Auto: bubblewrap on Linux, Seatbelt on macOS, AppContainer on Windows, off in a container; None turns it off; a confined session gets the operator's session bus only with Orkeon:Tools:Shell:Environment:SessionBus = true, since a command can leave the sandbox through it), in one shell session per agent run Execute shell commands with allowlist/blocklist and timeout; without working_directory the command runs in the agent's root, else the file system's working directory (refused when there is none), and a relative one resolves against it and is held to the agent's root; outside an agent root, a writing command the working directory does not allow runs in the write directory (Orkeon:FileSystem:WriteDirectory, /output by default), and is refused naming that option when there is none; mount-prefixed virtual path arguments are resolved for the process (Read for a read-only command, every right for a command that can write) and physical paths in the output come back virtualized (a quoted path whole, a Windows base without case and with either separator; under WSL a Windows program gets and gives the Windows spelling, Orkeon:Tools:Shell:WindowsPaths); action = start_job runs a build or a test suite longer than one call as a detached job (output in /output/jobs/<id>.log, at most 16 live jobs per agent run, killed with the run) and returns a job_id, job_status reports running or the exit_code, job_tail returns the last tail_lines lines { "command": "cat /workspace/README.md", "timeout_seconds": 30 }; { "action": "start_job", "command": "dotnet test" }; { "action": "job_tail", "job_id": "<id>", "tail_lines": 40 }

Session and memory tools (Orkeon.Infrastructure) β€” AddOrkeonSessionTools()

Tool Class Use case
session_store SessionStoreTool Read/write/truncate/annotate the session buffer and its metadata; truncate keeps the head plus the last retain_count turns, as session_snip does, append_message adds one message without rewriting the buffer, get_state reads one key or several keys, set_state writes one key or several values and removes several keys; a multi-key write is all or nothing, a values / keys overlap or a key / value mixed with values / keys is refused, and in plan mode only the reads (get_state, read_messages, get_metadata) are admitted
session_snip SessionSnipTool Immediately truncate the conversation to the head message plus the last retain_count turns (default 3); a turn is a user request with the tool traces and the answer that follow it, so the cut never splits one; kept_from is the index of the first message kept, always a user message (-1 when nothing was removed or the head alone was kept)
session_stats SessionStatsTool Full session telemetry: messages, tokens, cost, call totals
session_cost SessionCostTool Cumulative session cost in USD with a per-model breakdown
token_budget TokenBudgetTool Context window size, used tokens and what fills them (used_tokens_by_kind: system, user, assistant, tool, other), available budget
memory_store MemoryStoreTool List/add/replace/delete/get typed memories (user/project/feedback/reference): add returns the entry's id, every entry carries created_at, list takes newest_first, replace retires a stale fact in place (same id and category). Kept per project in <Orkeon:Cli:Memory:RootDirectory>/<project slug>/memory.json when Orkeon:Cli:Memory:Persist is on (the REPL's default); in memory otherwise
memory_recall MemoryRecallTool Registered by AddOrkeonCognitiveMemory(configuration), not by AddOrkeonSessionTools(); RunnerHost calls it only when Orkeon:CognitiveMemory:Enabled is true. Recall what the crew of the call remembers (query, limit), ranked by composite score; opt-in (Orkeon:CognitiveMemory:Enabled), held only by a crew with memory: true

Decision tool (Orkeon.Infrastructure) β€” AddOrkeonDecisionProvider(configuration)

Tool Class Use case Call example
system_one_decide SystemOneDecideTool Ask the active decision provider (TypeSafe, Liquid or Kev, see Decision models) typed questions about a state: choice, score or noul, each answer with calibrated probabilities and a confidence; box questions are refused (images do not travel through a tool call) and the API key never appears in the request { "state": { "ticket": "Refund not received" }, "questions": { "urgent": { "type": "noul", "instructions": "Does the customer need an answer today?", "criteria": { "true": "An answer is needed today", "false": "It can wait" } } } }

MCP tool (Orkeon.Infrastructure) β€” AddOrkeonMcp(configuration)

Tool Class Use case Call example
mcp_prompt_get McpPromptGetTool Get a prompt template of a connected MCP server (prompts/get), its arguments filled in; without name, list the prompts the server offers. The text is data returned by the server, not an instruction {"server": "docs", "name": "review", "arguments": {"lang": "C#"}}

File tools (Orkeon.Tools.FileSystem) β€” AddOrkeonFileSystemTools()

A path is a virtual path that starts with a mount (/workspace/src/stats.js). A relative path resolves against the agent's working root, else the file system's working directory (/workspace by default), and the response echoes the absolute path; an empty path is refused, and a path outside the agent's root is refused before any I/O β€” the same holds for node_outline, node_read, structural_search, structural_rewrite, txt_search and mdx_search (Working directory and relative paths).

Tool Class Base Use case Call example
file_read FileReadTool FileToolBase<FileReadRequest, FileReadResponse> Read a text file whole or by line range (offset, limit; has_more when cut); one symbol goes through node_read, a search through grep { "path": "/data/report.txt" }
file_write FileWriteTool FileToolBase<FileWriteRequest, FileWriteResponse> Write the whole content of a file, creating folders if necessary (append adds to it); a change inside a file goes through edit_file { "path": "/output/result.txt", "content": "Analysis complete.", "append": false }
edit_file EditFileTool FileToolBase<EditFileRequest, EditFileResponse> Replace a string in a file when it occurs exactly once, or every occurrence with replace_all { "path": "/workspace/a.txt", "old_string": "foo", "new_string": "bar" }
directory_read DirectoryReadTool FileToolBase<DirectoryReadRequest, DirectoryReadResponse> List the contents of a directory with glob filtering and recursion, at most max_results entries (200; truncated when the folder holds more) { "path": "/data", "pattern": "*.csv", "recursive": true }
directory_search DirectorySearchTool ToolBase<DirectorySearchRequest, DirectorySearchResponse> RAG semantic search across the files of a directory (ephemeral collection β€” needs the RAG subsystem at call time, see below) { "path": "/docs", "query": "deployment instructions", "file_patterns": "*.md;*.txt" }
count_pattern CountPatternTool FileToolBase<CountPatternRequest, CountPatternResponse> Deterministic regex occurrence count per pattern in one file (no LLM guessing); over a tree, grep with output_mode: "count" { "path": "/data/log.txt", "patterns": ["ERROR", "WARN"] }
glob GlobTool FileToolBase<GlobRequest, GlobResponse> Files matching a pattern under a mounted root, capped by max_results (pattern relative to path). Read-class { "path": "/workspace", "pattern": "**/*.cs", "max_results": 100 }
grep GrepTool FileToolBase<GrepRequest, GrepResponse> Line-by-line regex search returning path:line:text, capped by max_results / max_files, binary and over-1-MiB files skipped, per-match timeout; glob is a filter relative to path; a file as path is searched alone (a glob beside it is refused, naming the fix). Every answer carries total_matches, files_matched and scan_complete (false when a file over 1 MiB was left unread, the time budget ran out or max_files cut the scan) and truncated (true when a list or the counts were cut); output_mode: "count" drops the hit lines and returns the per-file counts instead, so a "how many" question over a tree takes one call. The default hits mode reads every candidate file up to max_files or the 20 s budget, even once max_results is reached, so that total_matches stays exact; a wide tree can end timed_out or truncated. Read-class { "path": "/workspace", "pattern": "TODO", "glob": "**/*.cs" }

directory_search β€” like txt_search, mdx_search and pdf_search below β€” searches through the RAG subsystem's ephemeral collections: the extension registers and constructs it without one, but a search fails at call time with an actionable message until the host calls AddOrkeonRag(configuration) and provides an embedding provider.

Data tools (Orkeon.Tools.Data) β€” AddOrkeonDataTools()

AddOrkeonDataTools() registers all 22 (it chains AddRelationalDatabaseTools(), AddMongoDbTools() and AddGraphDatabaseTools() internally).

Tool Class Use case Call example
csv_reader CsvReaderTool Read and structure CSV files with delimiter detection { "path": "/data/sales.csv", "delimiter": "," }
pdf_reader PdfReaderTool Extract text from PDF files with page selection { "path": "/docs/contract.pdf", "page_range": "1-5" }
json_tool JsonTool Manipulate JSON: parse (structure analysis), query (dot-notation navigation), format (pretty-print) { "operation": "query", "input": "{...}", "query": "data.users[0].name" }
xml_parser XmlParserTool Parse XML from a file path or a string, with XPath queries { "input": "/data/feed.xml", "operation": "query", "xpath": "//item/title" }
docx_reader DocxReadTool Read Word files with text, table and metadata extraction { "file_path": "/docs/report.docx" }
docx_writer DocxWriteTool Create Word files (.docx) with title, paragraphs and bullet lists { "file_path": "/output/report.docx", "title": "Monthly Report", "paragraphs": ["Introduction text..."] }
xlsx_reader XlsxReadTool Read Excel files (.xlsx): sheets, rows, columns, metadata (ClosedXML) { "file_path": "/data/budget.xlsx", "sheet_name": "Q3" }
xlsx_writer XlsxWriteTool Create or update Excel files (.xlsx) with multiple sheets, headers and rows { "file_path": "/output/summary.xlsx", "sheets": [{ "name": "Totals", "headers": ["Region", "Revenue"], "rows": [["EMEA", "1.2M"]] }] }
relational_database_query RelationalDatabaseTool Execute SQL queries (SQL Server, PostgreSQL, MySQL, MariaDB, SQLite); provider_name is the ADO.NET provider (Microsoft.Data.SqlClient, Npgsql, MySqlConnector, Microsoft.Data.Sqlite) { "connection_string": "...", "provider_name": "Npgsql", "query": "SELECT * FROM orders WHERE status = @status", "parameters": { "status": "pending" }, "query_type": "select" }
sqlserver_query SqlServerDatabaseTool Specialized SQL Server queries β€”
postgres_query PostgresDatabaseTool Specialized PostgreSQL queries β€”
mysql_query MySqlDatabaseTool Specialized MySQL queries β€”
mariadb_query MariaDbDatabaseTool Specialized MariaDB queries β€”
database_schema DatabaseSchemaTool Relational schema inspection (tables, columns, indexes, foreign keys) β€”
mongodb_query MongoDbTool Execute MongoDB operations (Find, Aggregate, CRUD) { "connection_string": "...", "database": "shop", "collection": "products", "operation": "find", "filter": "{ \"price\": { \"$gt\": 100 } }" }
mongodb_schema MongoDbSchemaTool MongoDB collection schema inference by sampling documents β€”
arcadedb_query ArcadeDbTool Queries against the ArcadeDB graph database β€”
janusgraph_query JanusGraphTool Gremlin traversals against JanusGraph β€”
graph_schema GraphSchemaTool Graph database schema inspection (vertex/edge labels, properties, indexes) β€”
pdf_search PdfSearchTool Semantic search in PDF files via embeddings (RAG subsystem required at call time) β€”
txt_search TxtSearchTool Semantic search in text files (RAG subsystem required at call time) β€”
mdx_search MdxSearchTool Semantic search in MDX/Markdown files (strips frontmatter and JSX; RAG subsystem required at call time) β€”

Web tools (Orkeon.Tools.Web)

AddOrkeonWebTools() registers the first six; each of the others has its own opt-in extension because it needs a key or an extra backing service. The keys do not travel the same way: the Tavily and OpenAI keys are secrets resolved at call time, the Brave and Slack tokens are handed to their extension by the host. No tool takes a secret as a call argument β€” what an argument carries passes through the conversation, the tool-call log and the usage record. Every tool that fetches a URL goes through the SSRF guard (fail-closed even without a registered IUrlValidator) and a named client that refuses redirects.

Tool Class Registration Use case
http_api HttpApiTool AddOrkeonWebTools() HTTP REST calls (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS) with SSRF protection. For the permission gate, GET, HEAD and OPTIONS (and a missing method, sent as GET) are reads, any other method an execution
web_scrape WebScrapeTool AddOrkeonWebTools() Scrape a web page with optional CSS filtering; cached=true chunks and embeds the page into the RAG cache
scrape_element ScrapeElementTool AddOrkeonWebTools() Targeted scraping of DOM elements via CSS selectors (text, HTML, attributes)
github GitHubTool AddOrkeonWebTools() β€” the token is read at registration from Orkeon:Tools:GitHub:Token, the variable Orkeon:Tools:GitHub:TokenVariable names (default GITHUB_TOKEN), then GH_TOKEN; without one the calls are anonymous, write actions are refused and the description says where to set it (configuration) GitHub API v3 (action: list_issues, create_issue, get_pr, search_repos, get_repo, create_pr). create_pr takes base, head, title and an optional body, and returns the pull-request URL in the url of its single result item; it needs a token with pull-request write scope. For the permission gate, list_issues, get_pr, search_repos and get_repo are reads (allowed in plan), create_issue, create_pr and an unknown action executions
image_generation ImageGenerationTool AddOrkeonWebTools() (needs an IFileSystemService and an ISecretProvider) β€” the secret OPENAI_API_KEY is resolved at call time (by default the ORKEON_OPENAI_API_KEY environment variable, then Secrets:OPENAI_API_KEY); without it a call fails naming the secret Image generation via the OpenAI DALL-E API, optionally saved under a virtual path (save_to_path)
firefox FirefoxTool AddOrkeonWebTools() (needs an IFileSystemService) β€” Firefox must be installed on the host; it starts at the first call of an agent run, on a disposable profile or on one the host names, and closes with the run β€” or is shared between runs, one browser per profile, with SharedInstance, or kept with its tabs from one run to the next with Lifetime: host (configuration) Drive a Firefox browser over WebDriver BiDi (action: navigate, back, snapshot, read, find, search, click, type, press, evaluate, screenshot, tabs, new_tab, switch_tab, close_tab, close). snapshot returns the page as an outline of sections, links and controls read from its semantic graph; each node carries an id (p2#7) that click, type, read and find take. search returns the sections closest in meaning to a query through the ephemeral RAG search (an error without the RAG subsystem). screenshot writes a PNG under a virtual path (save_to_path). An agent drives one tab at a time, among the ones it opened (tabs, new_tab, switch_tab, close_tab); an optional profile names, at the first call of a run, the profile the browser starts on among the ones the host allows. Every address the browser shows is checked by the SSRF guard. For the permission gate, navigate, back, snapshot, read, find, search, tabs, new_tab and switch_tab are reads (allowed in plan), screenshot an edit, click, type, press, evaluate, close_tab, close and an unknown action executions
web_search WebSearchTool AddOrkeonWebSearchTool() β€” the secret TAVILY_API_KEY is resolved at call time through ISecretProvider (by default the ORKEON_TAVILY_API_KEY environment variable, then Secrets:TAVILY_API_KEY in configuration) Web search via the Tavily Search API
brave_search BraveSearchTool AddOrkeonBraveSearchTool(apiKey) β€” orkeon run wires it only when BRAVE_API_KEY is set Web search via the Brave Search API
slack_send_message SlackTool AddOrkeonSlackTool(botToken) β€” no shipped root calls it (pure host opt-in) Send messages to Slack channels/users via the Web API
slack_read_messages SlackReadTool AddOrkeonSlackReadTool(botToken) β€” same host opt-in Read Slack messages (read-only)
cache_search CacheSearchTool AddOrkeonCacheSearchTool() (needs IEmbeddingService and IMemoryProvider) Semantic search over the RAG cache other tools populate (e.g. web_scrape with cached=true)

Event hub tools (Orkeon.Tools.EventHub) β€” AddOrkeonEventHubTools()

Seven tools, registered together with the in-memory hub (AddOrkeonInMemoryEventHub()). The full semantics live in EventHub and the crew lifecycle.

Tool Class Use case
publish_event PublishEventTool Publish an event on a topic (1β†’N broadcast), optional crew scope and metadata
post_message PostMessageTool Fire-and-forget message to a mailbox (agent://, crew://, topic://)
send_request SendRequestTool Send a request to a mailbox and wait for the correlated reply (timeout_ms required)
reply_to ReplyToTool Reply to a pending request identified by its correlation_id
receive_message ReceiveMessageTool Pull the next message from a mailbox (destructive read, crew-scoped)
wait_for_event WaitForEventTool Wait for the next event on a topic (exactly one of timeout_ms/wait_forever)
get_last_value GetLastValueTool Read the last retained payload for a key (last-value cache)

E-mail tools (Orkeon.Tools.Email) β€” AddOrkeonEmailTools(configuration)

Thirteen tools over the accounts an operator declares under Orkeon:Tools:Email: IMAP, POP3 and SMTP through MailKit, Outlook.com and Microsoft 365 through Microsoft Graph. Until an account is declared the mailbox tools refuse every call, email_accounts lists none and email_parser, which reads a file, works. An agent names an account (account, or the default one) β€” never a server or a credential β€” and the account's Rights decide what it may do; email_send reaches only the recipients the account's Send:AllowedRecipients list allows. Message ids are opaque: pass them back exactly as email_search returned them. The Access column is the class the permission gate sees. New to the family? The mailbox tutorial gets one account working end to end. Every parameter is listed in the e-mail guide; results are sized to what the agent loop keeps, and cursor / offset resume exactly where a page or a slice ends. Setup for Gmail, Hotmail/Outlook.com and your own server, the security model and the orkeon email commands: E-mail tools.

Tool Class Right needed Access Use case Call example
email_accounts EmailAccountsTool none Read List the configured accounts: the name to pass as account, their rights, whether each is ready {}
email_folders EmailFoldersTool Read Read List the folders with their role (inbox, sent, drafts, trash, junk, archive, all) and message counts { "account": "work" }
email_search EmailSearchTool Read Read Search one folder, newest first: unread, flagged, from, to, subject, text, dates, attachments, or a provider-native raw_query (Gmail search syntax, Outlook KQL); at most limit messages per page (10 by default, 50 at most) and about ten in practice, the page being cut to a tool result β€” next_cursor alone says the folder is finished; total counts the matches on IMAP { "folder": "inbox", "unread_only": true, "since": "2026-09-01" }
email_read EmailReadTool Read (+ Organize with mark_read) Read Read one message: the untrusted-content notice and the screening verdict first, then headers, attachments and the body in slices (offset, max_chars 200–3000, default 2500, then next_offset) { "id": "<id from email_search>" }
email_save_attachment EmailSaveAttachmentTool Read, plus a writable mount Edit Save one attachment (index) or all of them into a virtual directory; names sanitized, nothing overwritten { "id": "…", "directory": "/output/attachments" }
email_create_folder EmailCreateFolderTool Organize Edit Create a folder (a label on Gmail); missing parents are created { "path": "Clients/ACME" }
email_rename_folder EmailRenameFolderTool Organize Edit Rename a folder's last segment; system folders are refused { "path": "Clients/ACME", "new_name": "ACME Corp" }
email_move EmailMoveTool Organize Edit Move messages to a folder path or role; answers each message's new id when the server gives it { "ids": ["…"], "destination": "archive" }
email_mark EmailMarkTool Organize Edit Mark read or unread (seen), flag or unflag (flagged, a star on Gmail) { "ids": ["…"], "seen": true }
email_delete EmailDeleteTool Delete; Purge with permanent: true Execute Move messages to the trash, or delete them for good; returns each deleted id and its new id in the trash { "ids": ["…"] }
email_draft EmailDraftTool Draft (+ Read to reply or forward) Edit Save a new message, a reply (reply_to_id, reply_all) or a forward (forward_id) in Drafts without sending it β€” the human-review path, no allow-list { "to": ["client@example.com"], "subject": "Quote", "text": "…" }
email_send EmailSendTool Send (+ Read to reply or forward) Execute Send a new message, a reply or a forward to the recipients Send:AllowedRecipients allows (an empty list allows nobody); From is always the account { "reply_to_id": "…", "text": "Received, thank you." }
email_parser EmailParserTool none (no account) Read Parse an .eml file from a virtual path; same output as email_read { "path": "/workspace/mail/invoice.eml" }

Drive tools (Orkeon.Tools.Drive) β€” AddOrkeonDriveTools(configuration)

Eleven tools over the cloud drives an operator declares under Orkeon:Tools:Drive: Google Drive through the Drive API v3 and OneDrive (personal or for work) through Microsoft Graph, both in plain HTTP. Until an account is declared and signed in (orkeon drive login), every tool but drive_accounts refuses each call saying what to do. An agent names an account (account, or the default one) β€” never a client or a token β€” and the account's Rights decide what it may do; an account's Root confines every call to a folder of the drive, an item outside it being reported as not found. Ids are the provider's own and opaque; root names the account's root folder wherever a folder id is taken. drive_share reaches only the addresses Share:AllowedRecipients allows, and public links stay off unless Share:AllowPublicLinks is set. Setup for both providers, the security model and the orkeon drive commands: Drive tools.

Tool Class Right needed Access Use case Call example
drive_accounts DriveAccountsTool none Read List the configured accounts: the name to pass as account, their rights, their root folder, whether each is ready {}
drive_list DriveListTool Read Read List a folder (the account's root by default), folders first; at most limit items per page (20 by default, 50 at most), the page fitted to a tool result β€” next_cursor resumes exactly after the last item shown { "folder_id": "root" }
drive_search DriveSearchTool Read Read Search by words, name, MIME type, kind, modification date or folder, inside the root; a Google Drive raw_query clause; OneDrive needs text or name_contains { "name_contains": "invoice", "mime_type": "application/pdf" }
drive_info DriveInfoTool Read Read One item's metadata, its browser address included { "id": "<id from drive_list>" }
drive_read DriveReadTool Read Read Read a text file, or a Google Docs, Sheets or Slides file through its text export: the untrusted-content notice and the screening verdict first, then the text in slices (offset, max_chars up to 3000, then next_offset); a PDF, an Office file or an image is sent to drive_download { "id": "…" }
drive_download DriveDownloadTool Read, plus a writable mount Edit Save a file into a virtual directory β€” a Google document exported to format (pdf, docx, xlsx, csv…); names sanitized, nothing overwritten { "id": "…", "directory": "/output/drive" }
drive_upload DriveUploadTool Write Edit Upload a file of the VFS into a folder, or replace an existing file's content with replace_id; a name already taken is refused; at most MaxUploadMegabytes (100 by default) { "path": "/output/report.pdf", "folder_id": "…" }
drive_create_folder DriveCreateFolderTool Write Edit Create a folder; a name already taken in the parent is refused { "name": "Reports" }
drive_move DriveMoveTool Organize Edit Move an item into another folder (destination_id), rename it (new_name), or both, inside the root { "id": "…", "destination_id": "…" }
drive_delete DriveDeleteTool Delete; Purge with permanent: true Execute Move an item to the trash, or delete it for good (Google Drive, OneDrive for work; a personal OneDrive refuses it) { "id": "…" }
drive_share DriveShareTool Share Execute Give allowed addresses read or write access (no notification unless notify), or create a public link when the account allows one { "id": "…", "recipients": ["boss@example.com"] }

Codebase analysis tools (Orkeon.Tools.Analysis) β€” AddRaggableTreeTools()

Twenty-nine tools over the RaggableTree semantic code graph β€” the full guide is RaggableTree.

Tool Class Use case
index_codebase IndexCodebaseTool Scan the codebase and build the full RaggableTree index; reloads the saved index from the cache (use_cache, default true; false rebuilds), parses max_parallelism files at once (0 = one per processor)
incremental_reindex IncrementalReindexTool Reindex only the files changed since a commit or an explicit list
index_status IndexStatusTool List every virtual root currently indexed
is_path_indexed IsPathIndexedTool Check whether a virtual path is covered by an indexed root
codebase_map CodebaseMapTool Structural map of the codebase at one level (L1 by default, L0–L3), at most max_entries (200), truncated when more exist
package_summary PackageSummaryTool Package (L1) details: file/symbol counts, entry points, exports (at most max_exports, 50), dependencies
symbol_detail SymbolDetailTool Expanded L3 symbol detail: signature, doc, metrics, members, callers/callees; expand: "inheritance" gives extends, implements, derived_by and implemented_by as FQNs
symbol_source SymbolSourceTool Deterministic source citation: path, lines, code, SHA-256, stable flag
codebase_search CodebaseSearchTool Hybrid (vector + BM25) search with ranked, cited hits, at most top_k (10), truncated when more match
dependency_graph DependencyGraphTool Dependency graph at a scope (L1 packages, L2 modules, L3 symbols): at most max_nodes nodes (200), truncated when the scope holds more, the cycles of the whole scope, at most max_cycles (20, largest first, cycle_count keeps the total) of at most max_cycle_members (50) members; include_mermaid / include_dot off by default
sub_graph SubGraphTool Sub-graph expansion around seeds, Forward or Backward, bounded by depth and max_nodes (100); include_mermaid off by default
edge_list EdgeListTool Every edge of the given edge_kinds (required) in the whole index, in a stable order and paginated (cursor, page_size up to 1000), each end as FQN and id, optionally kept to the edges with an end at or under root_fqn (a package or file by path, a type by FQN, a namespace by its files and name); total and next_cursor. Read-class
flow_trace FlowTraceTool Trace the call flow from a symbol, the shortest path to a target or every path within max_depth and max_paths (20); edge_kinds takes the workflow names (calls by default, inherits)
impact_analysis ImpactAnalysisTool Direct and transitive callers affected by changing a symbol, counted by package, at most max_nodes visited (500)
complexity_report ComplexityReportTool Top-N methods by complexity metrics, with median/P95
statement_query StatementQueryTool Query L4 statements by kind, parent FQN, or semantic similarity
access_cost AccessCostTool Port-access cost of members selected by fqns or changed_files (default: the working-tree changes), restricted to roots; receivers overrides the port-receiver regex. Read-class
documents_of DocumentsOfTool Symbols documented by the sections of a Markdown file (path). Read-class
documented_in DocumentedInTool Markdown sections that document a symbol (fqn): file, heading path, start line. Read-class
batch_anchors BatchAnchorsTool action: closure expands anchors (fqns, files) to contained nodes, callers and tests; action: overlap compares two anchor sets a and b and lists the shared nodes. Read-class
affected_tests AffectedTestsTool Test projects and test classes a change reaches through the graph (changed_files or base; neither means base = HEAD, the working-tree changes); answers all when it cannot bound the set. Read-class
node_outline NodeOutlineTool List the members of a source file in any loaded grammar, or the sections of a Markdown file, with selectors, byte and line ranges
node_read NodeReadTool Read one member by selector: text (leading comments and attributes included), range, SHA-256, uncut
node_replace NodeReplaceTool Replace one node by selector and expected SHA-256: refused on a stale hash or a newly introduced parse error, the file left untouched; marks the index dirty. Edit-class
structural_search StructuralSearchTool Structural search by pattern with $A / $$$ARGS metavariables, rule object or YAML rule file over the files of any loaded grammar or Markdown, bounded by max_results / max_files. Read-class
structural_rewrite StructuralRewriteTool Rewrite the nodes a pattern or rule matches with a fix template over the files of any loaded grammar; dry_run defaults to true; per-file diff, a file whose rewrite does not parse is refused alone; Markdown refused. Edit-class
node_insert NodeInsertTool Add a node inside a type, namespace or Markdown section (last member, siblings' indentation) or before/after an anchor node (its comments and attributes stay with it); no anchor hash needed; refused on a newly introduced parse error; marks the index dirty. Edit-class
node_ensure NodeEnsureTool Apply one idempotent intent operation to one file (ensure_using, ensure_import, ensure_field, ensure_member, ensure_section, insert_under_heading, replace_mermaid); a no-op writes nothing and reports applied: false; refused on a newly introduced parse error; marks the index dirty. Edit-class
edit_batch EditBatchTool Apply node_replace and node_insert operations over several files as one transaction: every file re-parsed (validate: "parse") or the build run (validate: "build"); all applied or every file byte-identical; lists each operation's range. Edit-class

Mounts and local embeddings

Tool Class Registration Use case
list_mounts ListMountsTool (Orkeon.Tools.Abstractions) AddOrkeonAbstractionTools() List the VFS mounts visible to the agent, with virtual paths and access rights. Typed result { mounts: [{ virtual_path, access, overrides: [{ virtual_path, access }] }] }
local_embed_text LocalEmbedTool (Orkeon.Tools.Embeddings.Local) AddOrkeonLocalEmbeddings() Embed texts on-device (BGE-micro-v2 ONNX, 384 dims, CPU β€” no network at run time, no API key; the first build of a consumer downloads the model from huggingface.co; ExcludeAssets="build" on every reference that reaches the package skips the download, and the first embedding then fails unless the model is at LocalEmbeddingsModel/default/model.onnx or LocalEmbeddingOptions.ModelPath names one, see limitations)

Host-side tools

Tool Class Registration Use case
progress_report ProgressReportTool (Orkeon.Cli.Commands.Scripting) AddScriptCommands(...) (the scripted-commands host) Report the progress of a long-running scripted operation to the CLI status line
spawn_agent SpawnAgentScriptTool (Orkeon.Scripting) the script host, always offered to the model in act Run a named agent of the crew as a child and return its output, under a child budget (depth + 1); { "agent": "researcher", "input": "Summarise the findings" }

Outside the catalogue

Deliberately not part of the 124 built-in tool classes:

  • brief_submit / blueprint_submit β€” internal to the orkeon forge command (ForgeSubmission.cs, Orkeon.Scripting.Cli); the engine's own agents use them, a crew never lists them.
  • McpToolAdapter (Orkeon.Infrastructure.MCP) β€” bridges an external MCP server tool into IBaseTool; its name is the remote tool's, decided at runtime (see MCP).
  • JsTool (script-defined dynamic tools), MockTool (test double), ObservedTool (telemetry decorator) and AIAgentTool (Orkeon.Interop.AgentFramework β€” wraps a Microsoft Agent Framework agent you supply) β€” infrastructure matching the file glob, excluded by the counting rule.

Summary by category

Counting concrete tool classes with the rule stated at the top of this page β€” the number the README and the documentation index state, checked by scripts/check-doc-claims.py:

Package Tool classes
Orkeon.Tools.Data 22
Orkeon.Tools.Analysis (RaggableTree β€” see its guide) 29
Orkeon.Tools.Email (see its guide) 13
Orkeon.Tools.Drive (see its guide) 11
Orkeon.Infrastructure (collaboration, session, sandbox, human input, semantic_search, system_one_decide, memory_recall, mcp_prompt_get) 15
Orkeon.Tools.Web 11
Orkeon.Tools.EventHub 7
Orkeon.Tools.FileSystem 8
Orkeon.Tools.Rag 3
Orkeon.Tools.Abstractions / Orkeon.Tools.Code / Orkeon.Tools.Embeddings.Local / Orkeon.Cli.Commands.Scripting / Orkeon.Scripting 1 each
Total 124

Availability by composition root

The two shipped composition roots do not register the same suites. Sources: RunnerHost.cs + RunnerExecution.cs/RunCommand.cs for the CLI, Program.cs for the REPL. orkeon run builds a different host for a YAML crew (through RunnerExecution) and for an .ork.ts script (directly on RunnerHost); where the two differ, the table says so. The service host orkeon-host builds on the same RunnerHost, so it has the RunnerHost suite β€” everything in the first column except semantic_search β€” and registers human_input itself: a question waits for its answer on POST /runs/{id}/input. orkeon mcp serve builds the host of orkeon run --list-tools and serves its tools to an MCP client, human_input aside β€” see MCP integration.

Suite / tool orkeon run (CLI) orkeon-repl (ConsoleApp)
FileSystem (8), Data (22), Web core (6), shell_command, list_mounts, session (6) βœ… βœ…
E-mail (13) β€” the mailbox tools refuse every call until an account is declared under Orkeon:Tools:Email βœ… (OAuth tokens under the internal /credentials root) βœ… password accounts only β€” the REPL keeps no token store, so an OAuth account is refused
Drive (11) β€” every tool but drive_accounts refuses each call until an account is declared under Orkeon:Tools:Drive and signed in βœ… (OAuth tokens under the internal /credentials root) registered, but every account is refused: all sign in with OAuth, and the REPL keeps no token store
EventHub (7) βœ… ❌
Analysis (29) βœ… (unless RaggableTree:Enabled = false) βœ…
local_embed_text βœ… while RaggableTree is enabled with its default local embedding provider βœ…
RAG (rag_search, rag_ingest, rag_eval) βœ… registered by every RunnerHost host β€” orkeon run in all its forms, orkeon-host, orkeon mcp serve β€”, with the ONNX reranker: a YAML agent that lists one receives it, a script reaches them as tools.ragSearch and rag.* βœ… registered, with the ONNX reranker: a YAML agent that lists one receives it
web_search, cache_search βœ… ❌
brave_search βœ… only if BRAVE_API_KEY is set ❌
slack_send_message, slack_read_messages ❌ (host opt-in) ❌
The tools of the MCP servers MCP:Servers declares βœ… connected before the crew loads, under their own names β€” an agent lists them in tools: like any other tool (see the resolution pipeline below) βœ… connected before the scripted commands load, under their own names
semantic_search βœ… for a YAML crew (wired by the run command) ❌
human_input βœ… for a YAML crew (on the event stream under --events, auto-approved otherwise) βœ… (console prompt)
ask_question_to_coworker, delegate_work_to_coworker per agent, when AllowDelegation is on per agent
spawn_agent (script, SpawnAgentScriptTool) βœ… offered to the model in the ctx.llm.act of a crew agent's body ❌ (a scripted command runs no crew agent)
spawn_agent (C# SpawnAgentTool) ❌ (host must register it) ❌
code_interpreter concrete-type registration only β€” not resolvable by name idem
progress_report ❌ βœ… (scripted commands)
system_one_decide βœ… when a decision provider is configured (Orkeon:Decision:Provider, or deduced from its section or API key) βœ… same rule
mcp_prompt_get βœ… when MCP:Servers declares servers βœ… same rule
memory_recall βœ… when Orkeon:CognitiveMemory:Enabled = true, held by a crew with memory: true ❌

orkeon forge builds on the runner host but removes shell_command and code_interpreter from the catalogue a forged crew draws from. The twelve mailbox tools stay in it: a try runs them on a fictitious trial mailbox and never reaches the operator's real one (see Forged crews). The eleven drive tools are removed too: there is no trial drive, and a try would read and change the operator's actual one.

Tool resolution by name (YAML β†’ instance)

When a crew is defined in YAML, tools are referenced by their name (the tool class's Name property). Resolution happens via IToolRegistry (Orkeon.Domain.Tools); AddOrkeonInfrastructure() registers the default ToolRegistry (Orkeon.Infrastructure.Tools, in the Orkeon package), which indexes every IBaseTool registered in DI by name, case-insensitively β€” the runners and any embedding host use the same one.

Resolution pipeline

YAML config: tools: ["relational_database_query", "csv_reader"]
       ↓
CrewFactory calls IToolRegistry.GetToolByNameAsync("relational_database_query")
       ↓
IToolRegistry looks up the registered tool with Name == "relational_database_query"
       ↓
Found β†’ attached to the Agent (AgentBuilder.WithTools())
Missing β†’
    StrictTools (the runners' default) β†’ the crew fails to load, listing the available tools
    lenient (the library default)      β†’ a warning, and the agent runs without that tool

The strictness is Orkeon:CrewFactory:StrictTools (true in the runners, CrewFactoryOptions.StrictTools false for a host of your own). Every tool the registry holds reaches an agent that names it β€” a ToolBase tool, a script tool, a RAG tool, the tool of a connected MCP server: IBaseTool is the one contract.

A name belongs to one tool. Two tools registered in DI under the same name stop the host at startup with an error naming the name and both types; a tool registered later under a name already held (IToolRegistry.RegisterToolAsync) is refused β€” the call returns false and the registered tool keeps the name.

Tool registration

Tools are registered in IToolRegistry at application startup via the DI extensions (each table above names the one that owns its tools):

services.AddOrkeonFileSystemTools();   // file_read, file_write, edit_file, directory_read, directory_search, count_pattern, glob, grep
services.AddOrkeonDataTools();         // the 22 data tools (relational + MongoDB + graph chained internally)
services.AddOrkeonWebTools();          // http_api, web_scrape, scrape_element, github, image_generation, firefox
services.AddOrkeonCodeTools();         // shell_command
services.AddOrkeonAbstractionTools();  // list_mounts
services.AddOrkeonSessionTools();      // session_store, session_snip, session_stats, session_cost, token_budget, memory_store
services.AddOrkeonInMemoryEventHub();
services.AddOrkeonEventHubTools();     // the 7 event-hub tools
services.AddOrkeonEmailTools(configuration); // the 13 email_* tools; the mailbox ones need a declared account
services.AddOrkeonDriveTools(configuration); // the 11 drive_* tools; they need a declared, signed-in account
services.AddRaggableTreeTools();       // the 29 analysis tools
services.AddOrkeonLocalEmbeddings();   // local_embed_text
services.AddSemanticSearchTool();      // semantic_search (the extension lives in Orkeon.Hosting)
services.AddOrkeonWebSearchTool();     // web_search
services.AddOrkeonCacheSearchTool();   // cache_search
services.AddOrkeonRag(configuration); services.AddOrkeonRagTools(); // rag_search, rag_ingest, rag_eval (opt-in)

rag_search/rag_ingest/rag_eval are opt-in β€” see docs/reference/opt-in-subsystems.md.

Names to use in YAML

The exact name to use in the YAML tools: section is the value of the tool class's Name property β€” the Tool column of every table above. Complete alphabetical mapping:

YAML name Class Package
access_cost AccessCostTool Orkeon.Tools.Analysis
affected_tests AffectedTestsTool Orkeon.Tools.Analysis
arcadedb_query ArcadeDbTool Orkeon.Tools.Data
ask_question_to_coworker AskQuestionTool Orkeon.Infrastructure
batch_anchors BatchAnchorsTool Orkeon.Tools.Analysis
brave_search BraveSearchTool Orkeon.Tools.Web
cache_search CacheSearchTool Orkeon.Tools.Web
code_interpreter SecureCodeInterpreterTool Orkeon.Infrastructure
codebase_map CodebaseMapTool Orkeon.Tools.Analysis
codebase_search CodebaseSearchTool Orkeon.Tools.Analysis
complexity_report ComplexityReportTool Orkeon.Tools.Analysis
count_pattern CountPatternTool Orkeon.Tools.FileSystem
csv_reader CsvReaderTool Orkeon.Tools.Data
database_schema DatabaseSchemaTool Orkeon.Tools.Data
delegate_work_to_coworker DelegateWorkTool Orkeon.Infrastructure
dependency_graph DependencyGraphTool Orkeon.Tools.Analysis
directory_read DirectoryReadTool Orkeon.Tools.FileSystem
directory_search DirectorySearchTool Orkeon.Tools.FileSystem
documented_in DocumentedInTool Orkeon.Tools.Analysis
documents_of DocumentsOfTool Orkeon.Tools.Analysis
docx_reader DocxReadTool Orkeon.Tools.Data
docx_writer DocxWriteTool Orkeon.Tools.Data
drive_accounts DriveAccountsTool Orkeon.Tools.Drive
drive_create_folder DriveCreateFolderTool Orkeon.Tools.Drive
drive_delete DriveDeleteTool Orkeon.Tools.Drive
drive_download DriveDownloadTool Orkeon.Tools.Drive
drive_info DriveInfoTool Orkeon.Tools.Drive
drive_list DriveListTool Orkeon.Tools.Drive
drive_move DriveMoveTool Orkeon.Tools.Drive
drive_read DriveReadTool Orkeon.Tools.Drive
drive_search DriveSearchTool Orkeon.Tools.Drive
drive_share DriveShareTool Orkeon.Tools.Drive
drive_upload DriveUploadTool Orkeon.Tools.Drive
edge_list EdgeListTool Orkeon.Tools.Analysis
edit_batch EditBatchTool Orkeon.Tools.Analysis
edit_file EditFileTool Orkeon.Tools.FileSystem
email_accounts EmailAccountsTool Orkeon.Tools.Email
email_create_folder EmailCreateFolderTool Orkeon.Tools.Email
email_delete EmailDeleteTool Orkeon.Tools.Email
email_draft EmailDraftTool Orkeon.Tools.Email
email_folders EmailFoldersTool Orkeon.Tools.Email
email_mark EmailMarkTool Orkeon.Tools.Email
email_move EmailMoveTool Orkeon.Tools.Email
email_parser EmailParserTool Orkeon.Tools.Email
email_read EmailReadTool Orkeon.Tools.Email
email_rename_folder EmailRenameFolderTool Orkeon.Tools.Email
email_save_attachment EmailSaveAttachmentTool Orkeon.Tools.Email
email_search EmailSearchTool Orkeon.Tools.Email
email_send EmailSendTool Orkeon.Tools.Email
file_read FileReadTool Orkeon.Tools.FileSystem
file_write FileWriteTool Orkeon.Tools.FileSystem
firefox FirefoxTool Orkeon.Tools.Web
flow_trace FlowTraceTool Orkeon.Tools.Analysis
get_last_value GetLastValueTool Orkeon.Tools.EventHub
github GitHubTool Orkeon.Tools.Web
glob GlobTool Orkeon.Tools.FileSystem
graph_schema GraphSchemaTool Orkeon.Tools.Data
grep GrepTool Orkeon.Tools.FileSystem
http_api HttpApiTool Orkeon.Tools.Web
human_input HumanInputTool Orkeon.Infrastructure
image_generation ImageGenerationTool Orkeon.Tools.Web
impact_analysis ImpactAnalysisTool Orkeon.Tools.Analysis
incremental_reindex IncrementalReindexTool Orkeon.Tools.Analysis
index_codebase IndexCodebaseTool Orkeon.Tools.Analysis
index_status IndexStatusTool Orkeon.Tools.Analysis
is_path_indexed IsPathIndexedTool Orkeon.Tools.Analysis
janusgraph_query JanusGraphTool Orkeon.Tools.Data
json_tool JsonTool Orkeon.Tools.Data
list_mounts ListMountsTool Orkeon.Tools.Abstractions
local_embed_text LocalEmbedTool Orkeon.Tools.Embeddings.Local
mariadb_query MariaDbDatabaseTool Orkeon.Tools.Data
mcp_prompt_get McpPromptGetTool Orkeon.Infrastructure
mdx_search MdxSearchTool Orkeon.Tools.Data
memory_recall MemoryRecallTool Orkeon.Infrastructure (opt-in, AddOrkeonCognitiveMemory)
memory_store MemoryStoreTool Orkeon.Infrastructure
mongodb_query MongoDbTool Orkeon.Tools.Data
mongodb_schema MongoDbSchemaTool Orkeon.Tools.Data
mysql_query MySqlDatabaseTool Orkeon.Tools.Data
node_ensure NodeEnsureTool Orkeon.Tools.Analysis
node_insert NodeInsertTool Orkeon.Tools.Analysis
node_outline NodeOutlineTool Orkeon.Tools.Analysis
node_read NodeReadTool Orkeon.Tools.Analysis
node_replace NodeReplaceTool Orkeon.Tools.Analysis
package_summary PackageSummaryTool Orkeon.Tools.Analysis
pdf_reader PdfReaderTool Orkeon.Tools.Data
pdf_search PdfSearchTool Orkeon.Tools.Data
post_message PostMessageTool Orkeon.Tools.EventHub
postgres_query PostgresDatabaseTool Orkeon.Tools.Data
progress_report ProgressReportTool Orkeon.Cli.Commands.Scripting
publish_event PublishEventTool Orkeon.Tools.EventHub
rag_eval RagEvalTool Orkeon.Tools.Rag (opt-in)
rag_ingest RagIngestTool Orkeon.Tools.Rag (opt-in)
rag_search RagSearchTool Orkeon.Tools.Rag (opt-in)
receive_message ReceiveMessageTool Orkeon.Tools.EventHub
relational_database_query RelationalDatabaseTool Orkeon.Tools.Data
reply_to ReplyToTool Orkeon.Tools.EventHub
scrape_element ScrapeElementTool Orkeon.Tools.Web
semantic_search SearchTool Orkeon.Infrastructure (opt-in, registered by Orkeon.Hosting)
send_request SendRequestTool Orkeon.Tools.EventHub
session_cost SessionCostTool Orkeon.Infrastructure
session_snip SessionSnipTool Orkeon.Infrastructure
session_stats SessionStatsTool Orkeon.Infrastructure
session_store SessionStoreTool Orkeon.Infrastructure
shell_command ShellCommandTool Orkeon.Tools.Code
slack_read_messages SlackReadTool Orkeon.Tools.Web (opt-in)
slack_send_message SlackTool Orkeon.Tools.Web (opt-in)
spawn_agent SpawnAgentTool Orkeon.Infrastructure (host-registered)
spawn_agent SpawnAgentScriptTool Orkeon.Scripting (script host, offered in act)
sqlserver_query SqlServerDatabaseTool Orkeon.Tools.Data
statement_query StatementQueryTool Orkeon.Tools.Analysis
structural_rewrite StructuralRewriteTool Orkeon.Tools.Analysis
structural_search StructuralSearchTool Orkeon.Tools.Analysis
sub_graph SubGraphTool Orkeon.Tools.Analysis
symbol_detail SymbolDetailTool Orkeon.Tools.Analysis
symbol_source SymbolSourceTool Orkeon.Tools.Analysis
system_one_decide SystemOneDecideTool Orkeon.Infrastructure (opt-in, AddOrkeonDecisionProvider)
token_budget TokenBudgetTool Orkeon.Infrastructure
txt_search TxtSearchTool Orkeon.Tools.Data
wait_for_event WaitForEventTool Orkeon.Tools.EventHub
web_scrape WebScrapeTool Orkeon.Tools.Web
web_search WebSearchTool Orkeon.Tools.Web
xlsx_reader XlsxReadTool Orkeon.Tools.Data
xlsx_writer XlsxWriteTool Orkeon.Tools.Data
xml_parser XmlParserTool Orkeon.Tools.Data

Registering a custom tool in the registry

For a custom tool to be usable in YAML, it must be registered in IToolRegistry:

// Option 1 β€” via DI (read by the default ToolRegistry)
services.AddSingleton<IBaseTool, MyCustomTool>();

// Option 2 β€” explicit registration at runtime
var registry = host.Services.GetRequiredService<IToolRegistry>();
await registry.RegisterToolAsync(new MyCustomTool());

Derive the tool from ToolBase (or implement IBaseTool directly) β€” see Creating a new tool. The tool will then be accessible in YAML through its Name:

agents:
  my_agent:
    tools:
      - "my_custom_tool"  # Matches the tool's Name property

Identified functional gaps

The following categories are not covered by the existing tools:

  • Structured file writing: docx_writer and xlsx_writer cover Word and Excel, but there is no structured CSV or PDF writer. FileWriteTool writes plain text only (a CSV can of course be written as text).
  • Data transformation: no ETL tool to convert between formats (CSV β†’ JSON, XML β†’ CSV, etc.).
  • Notifications and alerts: e-mail is covered β€” email_send, limited to each account's allow-list (see E-mail tools) β€” and Slack by a host opt-in; there is no SMS, push or Teams tool.
  • Version control: no native Git tool for commit, branch, diff (shell_command allows read-only git subcommands by default).
  • Calendar / Scheduling: no tool to interact with calendars (Google Calendar, Outlook, etc.).
  • Cloud storage: Google Drive and OneDrive are covered by the drive tools (see Drive tools); there is no tool for S3, Azure Blob, GCS, Dropbox, nor for Google shared drives and SharePoint libraries.
  • OAuth authentication: no generic tool for the OAuth flows required by third-party APIs β€” OAuth exists only for e-mail and drive accounts, signed in once with orkeon email login or orkeon drive login.
  • Image processing: images reach a model through the opt-in multimodal pipeline (AddOrkeonMultiModal, IMultiModalContentLoader), but no tool transforms or analyses an image; image_generation only creates one.