Query project documents, parsed business files, and shared context. Use this first for source truth and narrative documentation. Returns ranked sections within token budget. If a broad query times out, retry once with a narrow 3-8 term query, max_tokens 800-1500, search_mode='keyword', return_references=true, auto_decompose=false, and include_all_tiers=false. For exact text use rlm_search; for structural code context use rlm_code_neighbors, rlm_code_callers, or rlm_code_imports.

Search documentation for a regex pattern.

Read specific lines from documentation.

Find callers of a code symbol using the persisted code graph.

List imports for a code symbol or file, or find importers of a module.

Return the local code subgraph around a symbol.

Find the shortest structural path between two code symbols.

Break complex query into sub-queries with execution order.

Execute multiple queries in one call with shared token budget.

Generate full execution plan for complex questions. Returns steps for decomposition, context queries, and synthesis.

Query across all projects in a team. Requires team API key.

Set session context for subsequent queries.

Show current session context.

Clear session context.

Show documentation statistics.

List indexed document sections with optional pagination and filtering.

Get current project settings from dashboard (max_tokens, search_mode, etc.).

Get intelligent tool recommendations based on what you want to do. Helps discover the right tool for your task.

Store an LLM-generated summary for a document.

Retrieve stored summaries.

Delete stored summaries.

Load project-linked shared standards, business playbooks, and reusable guidance. Use for linked source documents, not durable memory.

List available prompt templates from shared collections.

Get a specific prompt template by ID or slug. Optionally render with variables.

List all shared context collections accessible to you. Returns collections you own, team collections you're a member of, and public collections. Use this to find collection IDs for uploading documents.

Create a new TEAM shared context collection in the current project's team. Use this to separate project-specific best practices from broader team context.

Inspect the documents stored in a shared context collection, including optional full content. Use this before copying or splitting mixed collections.

Link an existing shared collection to a project you can access. Defaults to the current project when project_id_or_slug is omitted.

Unlink a shared collection from a project you can access. Defaults to the current project when project_id_or_slug is omitted.

Upload or update a document in a shared context collection. Use for team best practices, coding standards, business playbooks, reusable examples, and guidelines. Requires Team plan or higher.

List Team Business Context collections for the current team, including Business Response Playbook, Business Library, Offer Templates, Company Presentations, and Reference Diagrams. Use this before uploading reusable business knowledge.

Create or return an existing Team Business Context collection. Prefer preset slugs for the standard workspace business library.

Upload or update a reusable document in a Team Business Context collection. For current client/project files with metadata, use rlm_upload_document instead.

List client/project business-context workspaces in the current team. These are project-scoped containers for current client documents, deliverables, diagrams, and history.

Create a client/project business-context workspace in the current team. Use this before uploading current client documents with rlm_upload_document.

Store a durable Memory V2 record for later semantic recall. Direct writes support fact, decision, learning, preference, todo, and context. Use the narrowest owner scope: agent for one agent role, project for one client/project/RFP, team for reviewed shared standards, and user for one person's preferences. Do not store source truth here; use rlm_context_query, rlm_load_document, or rlm_shared_context for specs, RFPs, diagrams, and raw docs. Use rlm_end_of_task_commit for workflow capture.

Store a durable Memory V2 record only if it is sufficiently novel compared with existing memories. Direct writes support fact, decision, learning, preference, todo, and context. Use context tools for source truth and rlm_end_of_task_commit for workflow capture. Returns duplicate matches when skipped.

Persist durable outcomes from a task summary into memory. Extracts decisions, learnings, preferences, todos, and durable workflow context while filtering operational receipts; not for source documents or specs.

Store multiple durable Memory V2 records in a single call. Batch embedding for efficiency. Max 50 memories per call. Do not bulk-store source documents; upload or query source truth through context tools instead.

Semantically recall durable Memory V2 records such as decisions, learnings, preferences, and session carryover. Not for source document retrieval; use rlm_context_query, rlm_load_document, or rlm_shared_context for specs, RFPs, diagrams, and raw docs.

List memories with optional filters and sorting.

Delete memories by ID or filter criteria.

Invalidate a Memory V2 record without deleting it. Accepts a legacy memory ID if a migration map exists.

Attach structured evidence to a Memory V2 record. Accepts a legacy memory ID if a migration map exists.

Mark one Memory V2 record as superseded by another. Accepts legacy memory IDs if migration maps exist.

Verify whether a Memory V2 record still has valid supporting evidence.

Private review surface for candidate, stale, or rejected memories that need human inspection before they become agent memory.

Private review surface to accept, reject, archive, invalidate, merge, or supersede one queued memory item.

Append an entry to today's journal. Journals are daily logs of operational notes, decisions, and context. Auto-loads today + yesterday on session start.

Get journal entries for a specific date. Returns all entries from that day's operational log.

Get journal entries for a date, ready for summarization. Use before archiving old journals.

Get tiered durable memories for session bootstrap, with optional short-lived carryover. Use at session start to restore memory state, not to retrieve source documents.

Compact and optimize memories. Deduplicates similar memories, promotes frequent learnings to CRITICAL tier, and archives old entries.

Read-only status for the current engine session memory bootstrap. Reports whether bootstrap ran, when it ran, and how many memories/profiles were injected.

Read-only memory hygiene diagnostics. Returns active memory counts, top categories, auto-compaction threshold status, and samples of known noise/anomaly patterns without mutating memory.

Read-only duplicate/supersession review candidates. Groups exact and near duplicate memories and suggests which IDs to keep or supersede without mutating memory.

Read-only grouped memory cleanup candidates. Returns noise, duplicates, possibly stale memories, category anomalies, and review-queue items without mutating memory.

Generate a 'Top N active constraints' daily brief. Summarizes critical decisions, active rules, and pending todos.

Create a structured tenant/client profile. Stored as CRITICAL memory for auto-loading. Use for client onboarding.

Get tenant profile(s) for a project. Returns latest profile if tenant_id not specified.

Create a new agent swarm for multi-agent coordination.

Join an existing swarm as an agent.

Get an agent's profile (identity, personality, boundaries). Auto-loaded on session start for swarm agents.

Update an agent's profile. Use to set personality, boundaries, communication style.

Claim exclusive access to a resource (file, function, module). Claims auto-expire.

Release a claimed resource.

Read shared swarm state by key.

Write shared swarm state with optimistic locking and optional TTL.

Poll for state changes across multiple keys. Returns only keys that changed since last_versions. Use for efficient multi-key monitoring without individual get calls.

Send an event to all agents in the swarm.

Query and filter broadcast events in a swarm.

Compatibility alias that creates a canonical HierarchicalTask N3 work item. Prefer rlm_htask_create for explicit hierarchical workflows; use this for simple queue-style task creation.

Compatibility alias that creates multiple canonical HierarchicalTask N3 work items in one call. Max 50 tasks per call.

Compatibility alias that claims a canonical HierarchicalTask N3 task. If task_id is omitted, claims the highest-priority available task.

Compatibility alias that completes or fails a canonical HierarchicalTask N3 task with legacy queue-style inputs.

List canonical HierarchicalTask N3 tasks with cursor-based pagination for efficient iteration.

Enhanced version of rlm_tasks with:

• Cursor-based pagination for large task queues

• Returns owner (agent who claimed/completed)

• Updated_at timestamp for ordering

Use rlm_htask_tree for full hierarchy. Use this for queue-style dashboards and progress reports.

Get aggregated statistics for canonical HierarchicalTask N3 tasks in a swarm.

Returns counts by status:

• done: Completed tasks

• in_progress: Currently claimed tasks

• blocked: Pending tasks with unmet dependencies

• pending: Ready tasks waiting to be claimed

• failed: Failed tasks

• cancelled: Cancelled tasks

• total: Total task count

This is the queue-style progress view. For full workflow status, use rlm_htask_metrics or rlm_htask_tree.

Get canonical htask status change events for a swarm through the legacy task surface.

Filters to task-related htask events such as create, claim, complete, fail, update, unclaim, reassign, and delete.

Use with 'since' parameter to get incremental updates for calculating "tasks closed since last check".

Get swarm agent status with pending tasks and clear instructions.

Call this at session start to discover tasks assigned to you. Returns:

• Pending tasks assigned to your agent (use rlm_task_claim to start)

• Active swarms you've joined

• Current task you're working on (if any)

• Clear instructions on what to do next

This is THE discovery tool for swarm agents - tells you what work is waiting.

Remove an agent from a swarm.

Use this to:

• Clean up inactive/crashed agents

• Remove yourself from a swarm when done

• Free up agent slots for others

What happens on removal:

1. All resource claims held by the agent are released

2. Pending/claimed tasks assigned to the agent are unassigned

3. The agent record is deleted from the swarm

The agent can rejoin later with rlm_swarm_join.

List all agents in a swarm with their status.

Returns each agent's:

• agent_id: The agent's identifier

• role: coordinator, worker, or observer

• status: active, idle, busy

• capabilities: What the agent can do

• current_task: What they're working on (if any)

• joined_at: When they joined

Use this to:

• See who's in the swarm

• Find available agents for task assignment

• Monitor agent activity

Update swarm configuration (requires ADMIN access).

Updatable settings:

• name: Swarm display name

• description: What the swarm is for

• max_agents: Maximum agents allowed (plan-limited)

• task_timeout: Seconds before unclaimed task expires (60-3600)

• claim_timeout: Seconds a resource claim lasts (60-7200)

Reassign a canonical HierarchicalTask N3 task to a different agent through the legacy task surface.

Use this to:

• Move work from a busy/stuck agent to an available one

• Rebalance workload across agents

• Recover tasks from crashed agents

PENDING and queue-claimed tasks can always be reassigned. IN_PROGRESS tasks require force=true (admin override). COMPLETED/FAILED tasks cannot be reassigned.

Archive a canonical HierarchicalTask N3 task from a swarm through the legacy task surface (admin only).

Use this to:

• Remove cancelled or obsolete tasks

• Clean up test tasks

• Remove erroneously created tasks

Only PENDING, FAILED, or CANCELLED tasks can be archived by default. COMPLETED and IN_PROGRESS tasks require force=true.

Update canonical HierarchicalTask N3 properties through the legacy task surface (admin only).

Modifiable fields:

• title: Task title

• description: Task description

• priority: Task priority (higher = more urgent)

• status: Task status (PENDING, CLAIMED, IN_PROGRESS, COMPLETED, FAILED, CANCELLED, BLOCKED)

Note: Changing status to COMPLETED/FAILED sets completedAt automatically.

Unclaim a canonical HierarchicalTask N3 task, returning it to PENDING status.

Use this to recover tasks that are stuck (claimed but not progressing). The task will be available for any agent to claim again.

Find and recover stuck canonical HierarchicalTask N3 tasks in a swarm.

A task is considered stuck if it's CLAIMED or IN_PROGRESS but hasn't been updated within the threshold. Use dry_run=true to preview before recovering.

Upload or update a document in the project. Supports text documents (.md, .markdown, .mdx, .txt, .rst, .adoc) and binary parser documents (.pdf, .docx, .pptx, .svg, .vsdx). Binary payloads should use base64: except SVG, which may use raw XML.

Bulk sync multiple documents. Use for batch uploads or CI/CD integration.

Generate a native SVG companion context bundle and optionally upload the generated Markdown documents. Use dry_run=true to preview bundle IDs, paths, and payload size. Uploaded bundle documents store bundleId/sourceHash/sourcePath/artifactRole metadata.

Request access to a project.

Allows team members with NONE access level to request higher access levels (VIEWER, EDITOR, ADMIN) from project admins. Creates an access request that admins can approve or deny via the dashboard.

Load one exact source document by path. Use when you already know the document path and need direct source truth instead of ranked retrieval or memory recall.

Load structured map of all project documents with content. Returns a token-budgeted dump of every file, with optional path filtering. Use for full-project exploration.

Multi-round context exploration in a single call. Performs: (1) section scan for project structure, (2) ranked search for top relevant sections, (3) raw file load for highest-scoring documents. Combines search intelligence with raw access.

Bridge between Snipara's context optimization and RLM-Runtime's code execution.

PURPOSE: Package project documentation into a Python-ready format that can be injected into an rlm-runtime REPL session for context-aware code execution.

WORKFLOW:

1. Call rlm_repl_context to get context_data + setup_code

2. Use set_repl_context(key='context', value=context_data) to inject data

3. Use execute_python(setup_code) to load helper functions

4. Use helpers (peek, grep, find_function, etc.) to explore context

5. Execute code with full documentation context available

USE CASES:

• Implement features with documentation awareness

• Debug code with access to related docs

• Write tests referencing specifications

• Refactor with architecture docs available

Returns context_data (files + sections), setup_code (helper functions), and usage hints.

Retrieve full content by chunk ID. Use with rlm_context_query(return_references=True) to fetch full content of specific sections. This pass-by-reference pattern reduces hallucination by maintaining clear source attribution.

Create a structured decision record (ADR-style) for architectural or technical decisions.

Records decisions with context, rationale, alternatives considered, and revert plans. Auto-generates DEC-XXX IDs. Supports tags for categorization.

Use for:

• Architectural decisions (database choice, framework selection)

• Technical trade-offs (performance vs maintainability)

• Process decisions (deployment strategy, testing approach)

Query project decisions with filters.

Search by status, impact, scope, tags, or text query. Returns decisions sorted by recency with supersession chain info.

Supersede an existing decision with a new one.

Creates a new decision that replaces an old one, maintaining the chain of evolution. The old decision is marked as SUPERSEDED with a link to the new decision.

Get comprehensive index health metrics for your project.

Returns coverage, quality scores, tier distribution, stale document detection, and overall health score. Use this to monitor the health of your documentation index and identify issues.