Every machine below is a reusable building block (a registered tool the agency can invoke). A Production Station (WorkCenter) binds to one machine; a Production Pipeline (Routing) is an ordered set of stations - so the same machine is reused across any number of pipelines and clients, Factorio-style.
Tool.AddFile
machineAdd a public document (a PDF datasheet, a spec, a web page) to a library by its URL - SharePoint's Add-PnPFile. SPICE downloads it, extracts the text page by page and files it as one row; the reply names the row and its page count. Then read it with tool_get_file pages=1-2. Public URLs only.
Tool.AddNodes
machineAdd many nodes to the mind map in ONE call, all children of one parent - use it whenever the user asks to add, put or list things on the map. They wait for the user's approval. Args: parent (the node id, e.g. node-sharepoint; find it with Tool.SearchRows), titles (one title per line, or a JSON array).
Tool.AdvanceListItem
machineAdvance a list item to the next Status value declared on its ContentType's <Transitions/> block. Validates the transition; rejects unknown moves; returns the new Status + resolved NextForm/Skill hints. Mirrors the V12.2 human-facing /advance endpoint so agents can drive the same BaaN-style status workflow from MCP.
Tool.Advise
machineThe city advisor (anti-paperclip): gather the city's wisdom (KnowledgeArticles) + agency (crews) + open gaps + building blocks, analyse where the gaps are, and return ranked SUGGESTIONS - what to build/approve, which single-covered seats to staff, and the next standard to borrow. It PROPOSES, you dispose (never acts on a system change). Deterministic, no LLM. Compose before Tool.MakePage to publish the suggestions as a page. Args: none.
Tool.ApprovalGate
machineHuman-in-the-loop gate: halts a pipeline before a step that costs money (estimatedCostUsd over costThreshold, default 1.00) or is external (external=true), and raises a Pending checkpoint on /approvals. Passes through when approved=true, or when neither costly nor external. Args: approved, estimatedCostUsd, costThreshold, external, pipeline, reason, summary. Reusable governance station; no LLM.
Tool.ApproveBuild
machineApprove a PARKED autonomous build and build it: records the matching Approved entry on /approvals, then delegates to Tool.RequestCapability (ungated) to build the composable need. The human half of the anti-paperclip gate - autonomous builds are parked when gated; this is how the operator clears one. Args: need (required), routingId (optional), site (optional), from (optional).
Tool.ArXiv
machineInvoke Tool.ArXiv.
Tool.Ask
machineAsk the agency layer what handles a need. Posts your question (Chat) to the Hub bus and answers from the declared agencies/pipelines (deterministic, no LLM): recommends the best agency, its entry CEO to dispatch a Task to, and the pipelines it can run. Args: input (required), from (optional). The resolve step of the handoff router.
Tool.AutoGenesis
machineAutoGenesis - the gated self-build loop. Senses the city's most-demanded UNMET capability over GapSink (deterministic, no LLM), drafts a minimal-agency delta (AddAgency + entry AddActorProfile), and PARKS one Open ApprovalRequest per need. NEVER builds directly: a human Approve verdict drives the existing quorum + applier loop to birth the district (appears on /board/health at 'nodata' until it does real work). Honest + safe: refuses on thin signal (< 2 distinct non-seed origins, #30), self-excludes Genesis/AutoGenesis/seed demand (anti-paperclip), closes a need only when a WORKING agency serves it, caps district sprawl at 2 idle births, and enforces role >= Manager (the HTTP surface does not). Args: role (REQUIRED, >= Manager), from (default scheduler), floor (optional distinct-origin floor override). Returns an XML <AutoGenesis>.
Tool.BuildDivision
machinePropose a new department/agency SITE in the city - a Mission Division (its own lists, features and crew) - from a free-text description of what it should do. Deterministic and gated: it composes one AddSiteBlueprint (SiteTemplate.MissionDivision) and PARKS it as an Open ApprovalRequest; a human Approve verdict then builds the site. Never builds directly. Use this when the operator asks to 'build/create an agency or division that does X'. Args: task (REQUIRED - what the division should do), from (optional, default 'operator'). Returns an XML <DivisionProposal>.
Tool.BuildPipeline
machineSelf-evolution primitive: build a NEW pipeline at runtime from existing catalog machines, written as declared rows (WorkCenters + Routing + RoutingOperations) via the provisioning seam - so it appears on /blueprints and is runnable via Tool.RunPipeline immediately. No code, no new grammar. Args: routingId (required), then machines (csv of Tool ids, in order) OR need (composed from the catalog); optional site (default Manufacturing), title, product. Idempotent per row-Key.
Tool.CallConnector
machineMake the HTTP call declared by a Connector part - endpoint, verb, headers and body all come from the declaration, not from this call. Any extra arg is substituted into the connector's {{token}} placeholders. A connector whose endpoint contains an unresolved {{env:VAR}} is NOT called and reports so, which is how an outbound integration stays inert until an operator enables it. Args: connector (required - a Connector part Id), plus any tokens that connector declares.
Tool.Catalog.FitsRequisition
machineJudge every catalog candidate of a purchase requisition's category by the category's declared fit rules (the generated DT.Catalog.Fits.<Category>) and price them by the catalog rollups; recommend the cheapest fitting candidate delivered to the requisition's country within budget. Args: site, list, itemId (the requisition), recommend (true writes RecommendedOfferRef and a Fit check section on the requisition).
Tool.ChatAgent
machineChat with an agent or agency and get a real in-character reply. Composes the agent's persona (role/goal/backstory) and routes your message through the agent provider router (with cost + fallback - replies via the Echo stub when no provider key is set). Both your message and the reply post to the Hub bus as Chat, so the exchange animates on the Observatory and shows on /comms. Args: to (required agent/agency id; an agency answers as its entry CEO), input (required unless preview), from (optional, default 'operator'), preview (optional - when true, returns the agent's profile/CV + the exact JIT system prompt this tool injects, with NO LLM call and NO bus post), scope (optional - 'Site/List;Site/List', the lists Tool.SearchRows searches during this conversation), trace (optional - true ends the reply with '[steps] ...', the tools the agent used). Returns the reply text (or the profile when preview).
Tool.CityAutopilot
machineThe city's LLM-agent OODA step: one autonomous pass that OBSERVES the city (Tool.CityStatus), DECIDES the single next capability to build (Tool.Llm over the briefing), and ACTS (Tool.RequestCapability - build it when composable, else escalate a gap). Pure orchestration over existing machines; the composable-only safety boundary is inherited. Safe no-op when no real LLM is configured (offline Echo provider). Args: dryRun (optional, observe+decide without acting), requireApproval (optional - PARK the decided build for operator approval instead of running it), from (optional requester). Deterministic except for the model call.
Tool.CityStatus
machineQuery the city: one consolidated briefing of the platform's live state - machine + building-block + crew counts, the production lines that have run, pending approvals, and the open capability gaps (what needs doing). The read half of self-management; pairs with Tool.RequestCapability/BuildPipeline/RunPipeline to act. No args. Deterministic, no LLM.
Tool.ComposeBriefing
machineInvoke Tool.ComposeBriefing.
Tool.ContentOrganizerProcessing
machineRoute again everything still waiting in every site's Drop Off Library by that site's Content Organizer rules (SharePoint's Content Organizer Processing job). No arguments.
Tool.CostRollup
machineRoll up LLM spend recorded by the running cost store. Returns a Markdown summary covering total spend, top spending departments, and top spending models. Use sinceHours/sinceDays to scope to a period.
Tool.CrawlContentSources
machineCrawl the ticked content sources (SharePoint Search's Content Sources list) onto a mind map: each source's provider (FileShare, GitRepository, OneDrive, NextCloud) walks its start address to its crawl depth under the exclude rules, and every folder is upserted as a node under its parent folder - re-crawling merges. Args: site, sources (the Content Sources list), list (the mind-map list). Reads folder names, dates, README first lines and a repository's last commit only. No LLM call.
Tool.DeepResearch
machineInvoke Tool.DeepResearch.
Tool.DeleteListItem
machineDelete a list item (SharePoint UpdateListItems Cmd=Delete). The row goes to the site recycle bin, not away: restore it from /sites/{site}/_recycle. With the Write right you may delete rows you authored; deleting anyone else's row needs Manage. Args: site, list, itemId (the key tool_publish_to_list used, with or without 'item:').
Tool.Dispatch
machineResolve a need to the best declared agency + pipeline and RUN it: posts the Task to the Hub bus (Submitted->Done on /comms) and executes the pipeline via Tool.RunPipeline (cost + provenance on /production). Args: input (required need), site (optional, default Manufacturing), from (optional). The execute step of the handoff router.
Tool.DualDispatch
machineAssign the SAME task to two agencies, but only when they share the task's domain expertise (otherwise it single-dispatches). The same-domain decision reuses the deterministic agency ranker; each selected agency answers as its entry CEO through the provider router (cost gate + fallback). Outputs are A/B'd, posted to the bus as a MultiTask bundle (the eval loop scores each district), and filed to the wisdom ledger. Bounded to at most two dispatches - no swarm. Args: input (required task/brief), from (optional, default 'operator'), home (optional wisdom-library agency, default 'Agency.Research'), bar (optional min domain-match score, default 1), file (optional 'false' to skip filing). Returns an XML <DualDispatch> with each agency's answer.
Tool.EvaluateRun
machineEvaluate a populate run and file a ModelEval verdict: reads the most recent sources from the populated list, scores them with an LLM-as-judge on the five-dimension rubric (coverage, specificity, citation, actionability, honesty), and writes one ModelEvals row attributing the score to the model that produced the sources (recomparable over time). Args: site/department (default ResearchEnrichment), list (populated list to read, default Sources), evalList (default ModelEvals), task (default source-extraction), model (EvalModel override; defaults to the rows' dominant SourceModel), sample (recent rows to judge, default 8). Returns a pointer; writes no eval if there is nothing to judge or no provider answers (never fabricates a verdict).
Tool.ExportDeckPptx
machineExport a SlideAuthor-produced Markdown outline to a real .pptx (PowerPoint) file via dependency-free OpenXML. Same outline grammar as Tool.RenderSlideDeck (one '#'-heading per slide, '-'/'*' bullets). Args: outline (required), topic (optional cover title), audience (optional cover subtitle). Returns a Markdown summary followed by the package as Base64 ('data:pptx;base64,...'). For a click-to-download stream use the /studio/export/pptx endpoint.
Tool.ExportDocumentDocx
machineExport a DocAuthor-produced Markdown body to a real .docx (Word) file via dependency-free OpenXML. Same Markdown subset as Tool.RenderDocument (headings # ## ###, paragraphs, bullet/numbered lists). Args: markdown (required), title (optional), author (optional). Returns a Markdown summary followed by the package as Base64 ('data:docx;base64,...'). For a click-to-download stream use the /studio/export/docx endpoint.
Tool.ExtractSkill
machineSeal a successful production run into a new declarative <Skill> part - the missing half of the self-improvement loop, so proven routes compound instead of evaporating. Reuses the provisioning seam (<AddSkill>): no new part kind, no new write path; the run's machine sequence becomes the Skill's RequiresTool chain, and it round-trips on /agency/parts immediately. Honest by design: REFUSES to seal a run that did not succeed (#30), excludes the extractor's OWN runs (self-exclusion), and is idempotent. gate=approval PARKS a proposal at /approvals instead of writing directly (anti-paperclip; the autonomous RT-EXTRACT order uses this). When a department is resolvable (department= arg, else a meaningful run actor) it ALSO binds the sealed skill to that district's seats (AddSkillBinding -> a /coverage capability), best-effort so a bad department never loses the seal. Args: pipelineId (optional - else the latest successful non-extraction run), skillId (optional - else derived), category (default Processing), name, department (optional bind target), role (default Member), gate (approval=park, else direct), from. Returns an XML <SkillExtraction>.
Tool.ExtractSources
machinePopulate the Source Library: mine research text into N rated, taxonomized SourceCard rows. Routes one LLM call asking for each cited source as a labeled block (URL/TITLE/CATEGORY/RATING/WHY), clamps rating + category to the declared vocabulary, and writes the rows to the Sources list. Args: input (REQUIRED - research to mine, or a prior step's output), site/department (default ResearchEnrichment), list (default Sources), model (the SourceModel stamp; defaults to the provider used), max (cap, default 8). Returns a pointer; writes 0 rows + an honest error if no provider answers (never fabricates sources).
Tool.FetchKnowledge
machineFetch a knowledge slot by expression. Use this in mid-execution to pull data on demand rather than carrying everything in the front-loaded briefing. Argument: 'expression' = a Kind('arg', name=value) string. Supported kinds: ListView, SavedQuery, ActorMemory, Connector, Mcp, Vector, Graph.
Tool.FileIssue
machineFile what you cannot do or fix yourself, so someone picks it up: kind Bug (a tool or step failed), Improvement (a suggestion), New Feature (a missing tool or capability - name what it should do) or Feedback. Use it when you are stuck instead of guessing, then tell the person it is filed. Args: kind, title (one line), description (what happened or is needed, and why), context (optional: where).
Tool.FindStockMedia
machineFind real stock photos for a query via Pexels (free tier) - the stock visuals/B-roll station. Args: query (required, or 'topic'), count (optional 1-10, default 3), orientation (landscape/portrait/square). Returns Markdown with photo URLs + photographer credit + Pexels page. Gated on Plugins:pexels:ApiKey; degrades to a success notice when absent (pipeline-safe).
Tool.GenerateImage
machineGenerate an image. Selects a vendor via the 'provider' arg: pollinations (free/keyless, default), cloudflare (FLUX, free tier, 1024x1024), gemini (Nano Banana, needs billing), fal (paid). Args: prompt (required), provider (optional), model/width/height/steps (optional). Returns the image as a data:image base64 URI. One machine, interchangeable suppliers.
Tool.GenerateVideo
machineGenerate a short video clip via a configurable video-gen API. Args: prompt (required), durationSec (optional, default 8, capped at 60). Gated on Plugins:videogen:ApiKey + Plugins:videogen:Endpoint - degrades silently to a 'not configured' notice when either is absent. Endpoint is provider-agnostic (Sora / Veo / Seedance / RunwayML).
Tool.GetFile
machineRead the text of a document in a library (one tool_add_file added) - SharePoint's Get-PnPFile -AsString - a page range at a time. The reply starts with the page count and the source URL; ask for the next pages until you have what you need.
Tool.HarvestFeeds
machineFill the Source Library from the declared feed Connector parts (RSS/Atom). Fetches each feed, writes one SourceCard per item with the feed's own title/link/summary, and skips URLs already catalogued. Rates nothing - rows land SourceRating=Unrated. No LLM call. Args: connector (optional - one Connector id or a comma list), taxonomy (optional - a Connector Taxonomy group, e.g. Radar/Models); with neither, every untagged feed. site/list (default ResearchEnrichment/Sources), contentType (optional - a SourceCard child the list declares, e.g. ContentType.ModelRelease), max (per feed, default 15).
Tool.HarvestQuotes
machineRecord today's price for every instrument on the declared watchlist (Scope.Watchlist / Watchlist.Symbols) as one typed MarketSignal row per symbol per day: price, percent move since the previous close, currency, exchange and observation time. Keyless, no LLM. Re-running the same day is a no-op. Args: connector (default Connector.YahooQuote), site/list (default VentureEngine/Signals).
Tool.ListSchema
machineReturn the resolved field schema for a list as a JSON Schema document. Use this before emitting an AddListItem delta so the field names + types + Choice enums match what the list expects.
Tool.ListSiteTemplates
machineList the site templates a new site can be created from (SharePoint's template picker): key (e.g. STS#0), name, template id, category, what it brings (lists, features), description. Args: category (optional), catalogue (optional true: also SharePoint's full catalogue and the Fab 40, including templates not built yet).
Tool.Llm
machineInvoke Tool.Llm.
Tool.MakePage
machineParts-Factory machine: manufacture a SharePoint page artifact by cloning a declared page template (Scope.PageTemplates), filling its {{tokens}} from the args, and writing a ContentType.Page item (PageName/Title/Layout) into the site's pages library via provisioning - it then renders at /sites/{site}/Pages/{slug} through Page.xslt + MasterPage. Idempotent per page key. Args: site, pageName (required), title, template (default OneColumnHtml), list (default SitePages), plus template tokens.
Tool.MakeWebPart
machineParts-Factory placing machine (SP-on-prem AddWebPart): add a web part onto an existing page's zone. The web part is cloned from the Web Part Gallery (Scope.WebPartTemplates) by name, {{tokens}} filled from the args, then appended to the named Zone of the ContentType.Page's Layout and re-written via provisioning - it renders at /sites/{site}/Pages/{slug} through Page.xslt + IWebPartRegistry. Idempotent per Type+Title in the zone; edits storage-backed (Tool.MakePage) pages only. Args: site, pageName (required), webpart (required gallery key), zone (default Main), list (default SitePages), title, plus gallery tokens.
Tool.ModerateListItem
machineApprove or reject a list item on a list with content approval (SharePoint UpdateListItems Cmd=Moderate). status: 0 = Approved (everyone sees it), 1 = Rejected (only approvers and its author see it). comment is the approval comment (_ModerationComments). Needs the approve right on the list (Edit level or higher). Args: site, list, itemId (the row key, 'item:' prefix optional), status, comment (optional).
Tool.ProposeProject
machinePropose a mind-map node as a project (demand management): parks ONE approval that, when approved, creates the project on /sites/Projects (Status Planning), one ProjectTask per approved child node, and links the node (ProjectRef, Stage Project). The node moves to Stage Proposal now. Deterministic, no model. Args: site, list, itemId (the node), code (optional project code; default the first word of the title).
Tool.ProposeSiteKit
machinePropose a mind-map node's approved site kit (a PnP Provisioning Template, child shape-kit-<node>) as a site: maps it with the PnpToDelta XSLT into fields, content types and a list feature for the target site (a new site from the default template when it does not exist), and parks ONE approval; nothing is built until approved. Deterministic, no model. Args: site, list, itemId (the node), target (the site to build, letters and digits).
Tool.PublishToList
machinePublish a pipeline step's output as a typed, retrievable list item. Files the prior step's output (or an explicit body) as one row in a named list, so it is FetchKnowledge-retrievable via ListView and shows a real heading. Args: list (REQUIRED), site/department (REQUIRED), contentType (optional - validates the row), bodyField (the field that receives the body, default 'Body'), titleField (default 'Title'), title (optional - derived from the first line), summaryField (optional - gets a bounded lead from the body), key (optional - a stable row id, 'item:' prefix optional; default a fresh row-<guid>. Publishing again with the same key REPLACES that whole row, so a re-run is idempotent - to change single fields use tool_update_list_item), and field-<Name>=<value> for any extra typed fields. Returns a short pointer sentence (so a downstream SendMail delivers a pointer).
Tool.QualityGate
machineQuality-control inspection gate over the payload (defaults to priorOutput). Criteria: mustContain (';'-separated substrings all required), forbid (';'-separated substrings all absent), mustMatch (';'-separated XPath assertions, payload parsed as XML, each must hold). On pass: returns the payload unchanged (transparent). On fail: returns success=false so the run halts (QC gate + rework).
Tool.ReadinessScore
machineDeterministic readiness scorecard (no LLM) over the live Board.Health eval loop. Excludes Agency.Strategy's own district (an instrument must not grade itself) and emits a confidence / signal-density - refusing a confident verdict when the health signal is thin. The honesty half of the Strategy office; Tool.Roadmap consumes it. Args: none. Returns an XML <ReadinessScorecard>.
Tool.ReadNodes
machineRead mind-map items by id. detail=summary (default): title, path, status, one-line note, parent, children and links - use it first and walk the tree by reading the parent's or a child's id. detail=full: every column of the item. Args: ids (comma list, at most 15), detail (summary|full); site and list only for an item outside the map (a search hit names its Site/List).
Tool.RecycleBinCleanup
machineEmpty the recycle bins of every site: rows deleted longer ago than RecycleBinRetentionPeriod days are removed for good (SharePoint's Recycle Bin timer job). No arguments.
Tool.Registry
machineThe City Registry / Yellow Pages lookup: returns a role-scoped manifest of the tools you may use - each tool's mission, required + optional inputs, the output it returns, its taxonomy path, and the access level. Joins the declared Tool parts with their live arg schemas; gated by role. Progressive disclosure: SUMMARY by default (mission + taxonomy + output + access, no input breakdown), so you are not overloaded; pass detail=full for the required/optional inputs, or tool=Tool.X to drill ONE tool in full. Args: role (optional Assistant|Member|Lead|Manager, default Manager), query (optional taxonomy/name/mission keyword), detail (summary|full, default summary), tool (optional id to drill one). Returns an XML <Registry> of <Component>s.
Tool.RenderDocument
machineRender a DocAuthor-produced Markdown body into a self-contained HTML5 document with print-friendly CSS. Subset supported: headings (# ## ###), paragraphs, bullet lists (- or *), numbered lists (1.), bold (**text**), italic (*text*), inline code (`code`), links ([text](url)). Args: markdown (required), title (optional cover heading), author (optional byline). Returns complete HTML document.
Tool.RenderSlideDeck
machineRender a SlideAuthor-produced Markdown outline into a self-contained HTML5 deck. One <section> per '#'-prefixed slide heading; '-'/'*' bullets become <li> entries. Args: outline (required Markdown), topic (optional cover title), audience (optional subtitle). Returns the complete HTML document.
Tool.Request
machineThe agency front door: drop a need and it triages (via the declared DT.AgencyTriage DMN table) to Answer (Tool.Ask) | Process (Tool.Dispatch -> run a pipeline) | Decompose, then acts. The decision is logged on /comms. Args: input (required), kind (chat|task|multitask, default task), site (optional, default Manufacturing), from (optional).
Tool.RequestCapability
machineThe crew's capability front door: drop a need and it either BUILDS it from the existing building-block machines (delegates to Tool.BuildPipeline when fully composable) or REQUESTS a new block (files a gap to /gaps + /forge naming the missing primitive) when the crew can't build it from their blocks. Pure orchestration over Tool.ResearchGap + Tool.BuildPipeline + the gap backlog. Args: need (required), routingId (optional, derived from the need), site (optional, default Manufacturing), from (optional), requireApproval (optional - when true, a composable build is PARKED as a Pending approval on /approvals instead of built autonomously; approve with Tool.ApproveBuild).
Tool.RequestFeatureActivation
machineRequest a feature to be activated on a site (SharePoint's Manage site features > Activate) - parked for approval. Args: feature (Feature id), site (site name), justification (optional).
Tool.RequestFeatureStapling
machineRequest a feature to be stapled to a site template (SharePoint's FeatureSiteTemplateAssociation): every new site from that template gets the feature - parked for approval. Args: feature (Feature id), template (template id or key such as STS#0), justification (optional).
Tool.RequestSite
machineRequest a new site from an offered site template (SharePoint's self-service site creation with approval). Parks an Open ApprovalRequest; an approver's Approve verdict builds the site. Refuses hidden templates, existing site names and names that are not letters/digits. Args: template (SiteTemplate id), siteName, requester, justification.
Tool.ResearchGap
machineResearch a capability gap: compose a candidate pipeline from existing catalog machines (keyword match over Tool parts) and flag the need's aspects no machine covers as 'needs a new machine (code)'. Reuse-first; code is the rare escalation. Args: input (required need). Posts the proposal to /comms. Deterministic, no LLM.
Tool.ReviewInactiveSites
machineReview the farm for inactive sites (SharePoint's inactive site policy): lists the site collections with no new content in InactiveSite.Days, skipping locked sites and My Sites, and delivers one message a week to the operator's Hub inbox pointing at /admin/farm to lock them. Never locks anything. No args.
Tool.Roadmap
machineThe city's decider: gathers the deterministic readiness scorecard (Tool.ReadinessScore) and has the Chief Strategy Officer reason over it to produce an advisory verdict - what to build first and when, plus a go/no-go on a heavy hosted product - filed to the strategy ledger and rendered on /board/strategy. Honest by design: on thin signal it refuses a confident verdict without burning an LLM call (#30). Advisory only - recommends, never gates. Args: from (optional, default 'scheduler'). Returns an XML <Roadmap>.
Tool.RunPipeline
machineRun a production pipeline, threading each step's output to the next as 'priorOutput' and returning a JSON run record. DNA path: pass 'routingId' (+ 'site') to run a DECLARED Routing from the DB (its operations + station machine bindings). Ad-hoc path: pass 'steps' (JSON array of {name, tool, args?}). Any other args are shared run inputs (e.g. outline, topic). Fail-fast: a failed step stops the run and the partial record is returned.
Tool.Search
machineSearch the city's second brain across every retrieval engine at once - the XQuery spine (lexical over KnowledgeArticles) and the vector store (semantic over the same corpus), merged + score-ranked. Pass 'query' (free text); optional 'scope' (all|lexical|semantic) and 'limit'. Returns a <SearchResults> element with one <Hit engine source id title score> per result.
Tool.SearchRows
machineSearch list items (ideas, projects, tasks) by words, across the configured lists. Returns id, list, title, path and a snippet per hit - read a hit with Tool.ReadNodes. Use only when the items you were given do not answer the question. Args: query, limit (default 10), lists (optional 'Site/List;Site/List').
Tool.SelectXPath
machineRead only the slice of the payload you need: evaluate an XPath against an XML belt value and return the matched node(s)' value - a reusable filter station for the Pipes-and-Filters discipline (other belt keys flow on untouched). Args: xml (required, e.g. {{priorOutput}}), xpath (required), separator (optional, joins multiple matches). Deterministic, no LLM.
Tool.SendMail
machineDeliver a message to the operator's in-city mailbox (the Hub Inbox list, read at /sites/Hub/Lists/Inbox). The city has no real email - this list IS the inbox, so use this when you would 'email' or 'notify' the operator with a summary or update. Args: body (REQUIRED - the message; also accepts a prior pipeline step's output), subject (optional - derived from the first line if omitted), from (optional - who is sending), key (optional - an IDEMPOTENCY key; a recurring cadence should pass one per period, e.g. key=digest-2026-09-22, so a re-run REPLACES its row instead of appending another; omit it for genuine one-off mail and a fresh row is created). Returns an XML <MailDelivered>.
Tool.SendMessage
machinePost a typed message or task onto the Hub bus, addressed to an operator or agency (the agency send_message). Args: to (required target), input (required body/task description), kind (optional: chat|task|multitask, default task), expectedOutput (optional acceptance target), from (optional sender), status (optional explicit status, e.g. 'milestone'), parentId (optional - links a sub-task to its parent). Monitored on /comms.
Tool.SiteContents
machineWhat a site is for and what each of its lists holds (SharePoint's Site Contents), one line per list with links. Use it first when you need to find where something lives; then Tool.ListSchema for one list's fields. Args: site.
Tool.SuggestIdeas
machineSuggest child ideas for a mind-map node: reads the node, its path, siblings and children from the list, routes one model call, and writes each idea as a child row (Pending under content approval). Args: site, list, itemId (the node), steer (optional one-line direction), count (default 5, max 10).
Tool.SyncExternalList
machineKeep a list in step with a line-of-business system (SharePoint BCS External List): fetch each named Connector, map its body to rows with the connector's Transform, upsert every row by the key field - merge an existing item, add a new one. Args: connector (one id or a comma list), site, list, key (default ID), contentType (for new rows). No LLM call.
Tool.TrainingDrill
machineRun the city-agent training drills as an A/B leaderboard: for each declared challenge (Scope.TrainingDrills - a task + the expected tool) and each role, show a test agent the role-gated registry summary and score whether it discovers the right tool. The agentic-QA stage applied to AGENTS - 'can our agents use the city?'. Because the registry is role-gated, a lower role sees fewer tools and scores lower (a real capability surface). Each result posts to the bus so the eval loop scores Agency.Academy, and lands on /board/academy. Args: roles (comma-separated, e.g. 'Assistant,Member,Manager'), role (single, default Member), from (optional). Returns an XML <Leaderboard> with a <Run role= provider= score=> per role.
Tool.TransformXslt
machineTransform the XML payload with an XSLT - the declarative pipeline transform step (reuse-of-XSLT, no code per transform). Stylesheet: either mapper (a declared Scope.XsltMappers name e.g. Identity/Rename/Unwrap, reusable + token-filled from the args) OR xslt (an inline stylesheet string). xml is the payload to transform; defaults to priorOutput from the previous station. Returns the transformed XML/text. Decoupled: reads only its input + stylesheet, nothing about adjacent stations.
Tool.UpdateListItem
machineUpdate fields on an existing list item (SharePoint UpdateListItems Cmd=Update / MERGE): only the field-<Name>=<value> args you pass change; every other column keeps its value. Each field must be declared on the row's ContentType and its value must validate (Choice, Number, ...). Author and _-prefixed engine fields are refused. Same write as the list Edit form: versioning snapshot, policy gate, ItemUpdated alerts/webhooks. Args: site, list, itemId (the key tool_publish_to_list used, with or without 'item:'), field-<Name>. To move a Status along a declared transition use tool_advance_list_item.
Tool.WebFetch
machineFetch a public URL as text, after tool_web_search. Cite the URL.
Tool.WebSearch
machineInvoke Tool.WebSearch.
Tool.XQuery
machineQuery the SPICE XML spine (parts + KnowledgeArticles + the cycle ledger) with XQuery 3.1, offline, via Saxon. The corpus is namespace-stripped, so use plain paths: //KnowledgeArticle, //Cycle, //ContentType. Pass 'query' (an XQuery expression - FLWOR/grouping/order-by all work) OR 'tag' (a topic tag for the KB+cycles convenience). Returns the serialised result sequence.