NimbleBrain MCP server
Commit Nov 15, 2026A self-hosted platform for hosting MCP apps and agent automations with interactive UIs, scheduled runs, and multi-agent delegation.
Also known as NimbleBrainInc/nimblebrain
- Stars
- 28
- Tools
- 12
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 15, 2026
- License
- Apache-2.0
What is NimbleBrain MCP?
NimbleBrain is a self-hosted platform for hosting MCP apps and agent automations with interactive UIs, scheduled runs, and multi-agent delegation. It exposes 12 tools, such as nb__status, nb__search, nb__read_resource.
Summary generated from the project's README
About NimbleBrain MCP server
Developers and teams can host and manage MCP applications and agentic automations through this self-hosted platform. It provides an interactive sidebar UI with live data synchronization, allowing users to run agents on demand or via scheduled cron jobs. The system functions as both an MCP client that connects to remote connectors and an MCP server that exposes an aggregated toolset to external hosts via Streamable HTTP.
Setup involves deploying container images via Docker or running locally with Bun and Node.js. Users must provide an ANTHROPIC_API_KEY and configure an instance.json file to establish an identity provider. The platform uses a skill-driven approach where markdown files with YAML frontmatter inject system prompts and scope tool access. This architecture allows for complex agentic loops that iterate until tasks are complete, subject to configurable limits like a maximum of 25 iterations or specific token budgets.
What you can do with it
- 1Automate repetitive agent tasksSchedule agentic workflows to run automatically using a cron schedule.
- 2Manage tool access with skillsRestrict specific tools to certain tasks by using markdown-based skill definitions.
- 3Expose aggregated tools to other clientsTurn your collection of connected MCP servers into a single endpoint for external use.
- 4Monitor agent activity through a UITrack live agent data and interactions through an interactive sidebar interface.
Written from the project's README. Every use case is checked against a quote from it.
NimbleBrain MCP tools 12
Detected from the READMEnb__statusnb__searchnb__read_resourcenb__set_preferencesnb__manage_toolsnb__get_confignb__set_model_confignb__workspace_infonb__briefingnb__manage_usersnb__manage_workspacesnb__manage_connectors
| nb__status | — | |
| nb__search | — | |
| nb__read_resource | — | |
| nb__set_preferences | — | |
| nb__manage_tools | — | |
| nb__get_config | — | |
| nb__set_model_config | — | |
| nb__workspace_info | — | |
| nb__briefing | — | |
| nb__manage_users | — | |
| nb__manage_workspaces | — | |
| nb__manage_connectors | — |
Configuration
ALLOWED_ORIGINSANTHROPIC_API_KEY
| Name | Description | |
|---|---|---|
| ALLOWED_ORIGINS | — | |
| ANTHROPIC_API_KEY | — |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablenimblebraininc/nimblebrain is public and reachablegithub.com/nimblebraininc/nimblebrain ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-13github.com/nimblebraininc/nimblebrain ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model12 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubNimbleBrain
A self-hosted platform for MCP Apps and agent tasks. Install an MCP connector and you get more than tools — you get an interactive UI in the sidebar with live agent-UI data sync, and the ability to run the agent on demand or on a cron schedule. Full ext-apps host support on top of an agentic loop with skill-driven prompt composition.
Ships as container images on GHCR (ghcr.io/nimblebraininc/nimblebrain, ghcr.io/nimblebraininc/nimblebrain-web). Also exposes itself as an MCP server via Streamable HTTP so external MCP clients can consume the aggregated toolset.
Quick Start
Option 1: Docker (recommended)
# Prerequisites: Docker
export ANTHROPIC_API_KEY=sk-ant-...
# The identity provider. `dev` signs every request in as one local developer,
# with no login: keep it on your own machine.
echo '{"auth":{"adapter":"dev"}}' > instance.json
docker compose up
# Pulls ghcr.io/nimblebraininc/nimblebrain + nimblebrain-web
# Web UI: http://localhost:27246
# API: http://localhost:27246/v1/health
Open http://localhost:27246 in your browser. The runtime does not start without instance.json; for a real identity provider (oidc or workos), see instance.json.
To build from source instead of pulling (e.g. when developing against local changes), run docker compose up --build.
Option 2: Local development
# Prerequisites: Bun (https://bun.sh), Node.js 22+
export ANTHROPIC_API_KEY=sk-ant-...
bun install
bun run dev
# API on http://localhost:27247 (auto-restarts on file changes)
# Web on http://localhost:27246 (Vite HMR, proxies /v1/* to :27247)
One command, one terminal. Output is prefixed [api] / [web]. Ctrl+C stops both. The dev launchers write {"auth":{"adapter":"dev"}} to the workdir's instance.json when it has none.
For API-only development (no web client):
bun run dev:api
How It Works
User message
│
▼
┌─────────────────────────────────────────┐
│ Runtime.chat() │
│ │
│ 1. Skill matching (triggers → keywords)│
│ 2. System prompt composition │
│ 3. Tool filtering (per-skill scoping) │
│ 4. AgentEngine loop: │
│ LLM call → tool execution → repeat │
│ 5. Conversation persistence │
└─────────────────────────────────────────┘
│
▼
ChatResult { response, toolCalls, tokens, ... }
The engine loops until the model stops calling tools, hits the iteration limit (default 10, max 25), or exceeds the token budget.
How to Test and Verify
bun install
bun run verify # lint → typecheck → test → test:web → test:integration
# Or individually:
bun run test # Unit + integration tests
bun run lint # Biome linter
bun run check # TypeScript strict mode
# Web client — build verification
cd web && bun install
bun run build # TypeScript + Vite build → dist/
# Docker — validate configs
docker compose config # Validate compose file
HTTP API
All endpoints require authentication (Bearer token or session cookie) unless noted. Auth is configured via instance.json — see the identity system docs.
A route that acts on a workspace names it in its path, /v1/workspaces/:wsId/…, and admits only a member of it: a malformed, unknown or non-member id gets 404 workspace_error. Every other route acts on the caller, or on a conversation or file its own id locates, and names no workspace (ADR-0037). The path is the only way to name a workspace: a ws_<id>- qualified server, app or tool name is refused with 400, and a conversationId on a chat or upload must be one of the caller's conversations in the path's workspace, or the request gets 404 conversation_not_found, the same answer as for an id that does not exist.
| Method | Path | Auth | Description |
|---|---|---|---|
| GET | /v1/health | No | Health check |
| GET | /v1/bootstrap | Yes | Bootstrap workspace context (user, workspaces, shell config) |
| POST | /v1/workspaces/:wsId/chat/start | Yes | Start a turn that runs to completion on the server |
| POST | /v1/conversations/:id/cancel | Yes | Stop a conversation's in-flight turn |
| GET | /v1/workspaces/:wsId/apps/:name/resources/:path | Yes | Fetch app UI resource |
| POST | /v1/workspaces/:wsId/tools/call | Yes | Direct tool invocation |
| POST | /v1/workspaces/:wsId/resources/read | Yes | Read an MCP resource |
| POST | /v1/workspaces/:wsId/resources | Yes | Upload files (multipart) |
| GET | /v1/workspaces/:wsId/shell | Yes | Shell configuration (placements, endpoints) |
| GET | /v1/files/:fileId | Yes | Serve uploaded file (the id locates its workspace) |
| GET | /v1/events | Yes | SSE workspace event stream |
| GET | /v1/auth/authorize | No | OAuth authorization redirect |
| GET | /v1/auth/callback | No | OAuth callback handler |
| POST | /v1/auth/logout | No | Clear session and refresh cookies (requires Content-Type: application/json) |
| POST | /v1/auth/refresh | No | Refresh access token |
| GET | /.well-known/oauth-protected-resource/mcp/:wsId | No | MCP OAuth discovery for one workspace (RFC 9728) |
| GET | /.well-known/oauth-authorization-server | No | AuthKit metadata proxy (RFC 8414) |
| POST/DELETE | /mcp/:wsId | Yes | A workspace's Streamable HTTP MCP server endpoint (GET returns 405; no standalone server→client SSE channel; bare /mcp is refused) |
Architecture
NimbleBrain is both an MCP client (connecting to remote connectors over HTTP/SSE, and to the platform's own capabilities in-process) and an MCP server (exposing composed tools to external hosts via each workspace's /mcp/<wsId> Streamable HTTP endpoint). The ToolRegistry aggregates tools from all connected MCP servers into a single namespace, while skills scope tool access per task.
Three port interfaces isolate concerns:
| Port | Purpose | Implementations |
|---|---|---|
ModelPort |
LLM provider | AnthropicModelAdapter (prompt caching), EchoModelAdapter (tests) |
ToolRouter |
Tool discovery + execution | ToolRegistry (MCP sources + inline sources), StaticToolRouter (tests) |
EventSink |
Observability | WorkspaceLogSink, SseEventManager, ConsoleEventSink, DebugEventSink, NoopEventSink |
System Tools
All system tools are prefixed with nb__ (the nb source name + __ separator).
| Tool | Purpose |
|---|---|
nb__status |
Platform status: overview, connectors, skills, or config (scope param) |
nb__search |
Unified search: installed tools or the connector catalog (scope param) |
nb__read_resource |
Read a resource from an installed app's MCP server: a skill:// or ui:// resource, or one of the app's records by URI |
nb__set_preferences |
Set user preferences (name, timezone, theme) |
nb__manage_tools |
Promote/release tools in the active set |
Additional internal tools (UI-only, hidden from LLM) are listed in Architecture Reference.
Skills
Skills are markdown files with YAML frontmatter. They inject system prompts and scope tool access:
---
name: my-skill
description: What this skill does
metadata:
triggers: ["exact phrase match"]
keywords: [fuzzy, keyword, matching]
category: domain
allowed-tools: ["server__*"]
---
# System prompt content injected when this skill matches
Skill matching is two-phase:
- Triggers — exact substring match on the user message (first hit wins)
- Keywords — count keyword hits, require minimum 2 to qualify
Two categories of skills:
- Core (
src/skills/core/) — always injected into the system prompt (e.g.,bootstrap.mdteaches meta-tool usage) - User-matchable — loaded from
src/skills/builtin/(currently empty),~/.nimblebrain/skills/, and config-specified directories
Connectors
A connector is a remote MCP server the platform connects to over Streamable HTTP
or SSE. The runtime orchestrates over remote MCP: it holds a URL and a
credential, and never downloads, verifies, or executes a server's code — so
supply-chain review lives where a server is built and published, not in a process
that also holds tenant credentials. Every connector is aggregated into the same
unified tool namespace by the ToolRegistry.
No connectors are installed by default. Platform apps (conversations, files, usage, tasks, and the rest) are built in as in-process MCP sources (see src/platform/). Install connectors from the connectors catalog. Tool visibility follows the tiered surfacing rules described under Tiered Tool Surfacing.
Configuration
NimbleBrain splits configuration across two files:
nimblebrain.json— instance-level settings (models, HTTP, logging, limits, feature flags). One file per deployment.workspace.json— per-workspace settings (connectors, skill directories, optional model overrides). One file per workspace under<workDir>/workspaces/<ws-id>/.
This split is the workspace isolation boundary: two workspaces in the same deployment can install different connectors without touching the instance config. See Workspace Isolation below.
nimblebrain.json (instance config)
Create a nimblebrain.json in your working directory. A minimal file:
{
"$schema": "https://schemas.nimblebrain.ai/v1/nimblebrain-config.schema.json",
"version": "1"
}
A fully specified example:
{
"$schema": "https://schemas.nimblebrain.ai/v1/nimblebrain-config.schema.json",
"version": "1",
"models": {
"default": "anthropic:claude-sonnet-4-6",
"fast": "anthropic:claude-haiku-4-5-20251001"
},
"providers": {
"anthropic": { "apiKey": "sk-ant-..." },
"openai": { "apiKey": "sk-..." }
},
"http": { "port": 27247, "host": "127.0.0.1" },
"logging": { "dir": "~/.nimblebrain/logs", "level": "normal", "retentionDays": 30 },
"store": { "type": "jsonl", "dir": "~/.nimblebrain/conversations" },
"telemetry": { "enabled": true },
"files": { "maxFileSize": 26214400, "maxFilesPerMessage": 10 },
"features": { "catalogSearch": true },
"maxIterations": 25,
"maxInputTokens": 500000,
"workDir": "~/.nimblebrain"
}
Model slots. models takes two named slots — default (every chat turn) and fast (titles, the home briefing, and both history folds). Each is a provider:model-id string. providers supplies per-provider API keys when you want to mix providers across slots. A slot left unset resolves to the built-in default model, anthropic:claude-sonnet-4-6.
Feature flags. All default to true. Disable a flag to remove the capability entirely — the tool is unregistered, not visible to the LLM, and POST /v1/workspaces/:wsId/tools/call returns 403. See Feature Flags for the full set.
workspace.json (per-workspace config)
Each workspace has its own config at <workDir>/workspaces/<ws-id>/workspace.json.
{
"id": "ws_d6cb464050493d41",
"name": "Product",
"members": [{ "userId": "usr_default", "role": "admin" }],
"connectors": [
{ "url": "https://mcp.example.com/mcp", "serverName": "example" }
],
"skillDirs": ["./skills"],
"models": { "default": "anthropic:claude-opus-4-6" }
}
connectors, skillDirs, and optional models overrides live here, not in nimblebrain.json. skillDirs, home and preferences placed at the top level of nimblebrain.json are stripped on load — the runtime treats them as configuration errors rather than falling back to a global scope. A workspace-shaped connectors array there is rejected outright, because in that file the name is the provider and gateway block.
Workspace Isolation
Connectors, tool registries, and conversation data are scoped to a workspace. Every tool handler resolves its workspace via runtime.requireWorkspaceId() before touching data. It resolves from the workspace the request names, and throws when none is in scope.
Two workspaces that install the same connector spawn independent subprocesses with data directories under <workDir>/workspaces/<wsId>/data/<connector>/, so their entity data never crosses. Sidebar placements, briefing facets, and the app list are filtered per workspace.
Running the runtime
The runtime is launched with bun (there is no nb binary):
bun run start # serve: HTTP API server (production)
bun run dev # dev mode: API with file watching + web HMR
bun run start is bun run src/cli/index.ts serve; that explicit form (with --config, --port) is exactly what the container runs. Everything else — connectors, skills, credentials, tasks, telemetry — is managed from the web UI and the agent's tools, not the CLI.
Flags
Pass flags after the command, e.g. bun run start --port 8080 or bun run dev --no-web:
| Flag | Scope | Purpose |
|---|---|---|
--config <path>, -c |
serve, dev | Config file (default: ./nimblebrain.json) |
--debug |
serve, dev | Enable debug event logging |
--port <number> |
serve, dev | HTTP server port (default: 27247) |
--no-web |
dev | Skip web dev server (API only) |
The working directory is set via NB_WORK_DIR (see Environment Variables).
Environment Variables
Model providers
| Variable | Purpose |
|---|---|
ANTHROPIC_API_KEY |
Anthropic API key (required unless set via providers.anthropic.apiKey) |
OPENAI_API_KEY |
OpenAI API key (when using openai:* model slots) |
GOOGLE_GENERATIVE_AI_API_KEY |
Google Gemini API key (when using google:* model slots) |
GREENPT_API_KEY |
GreenPT API key (when using greenpt:* model slots) |
NEBIUS_API_KEY |
Nebius Token Factory API key (when using nebius:* model slots) |
XAI_API_KEY |
xAI API key (when using xai:* model slots) |
Runtime
| Variable | Purpose |
|---|---|
NB_WORK_DIR |
Override working directory (takes precedence over config) |
ALLOWED_ORIGINS |
Comma-separated allowed CORS origins (for cookie-based auth) |
NB_CHAT_RATE_LIMIT |
Chat requests per minute per user (default: 20) |
NB_TOOL_RATE_LIMIT |
Tool calls per minute per user (default: 60) |
NB_CONNECTOR_START_CONCURRENCY |
Max connectors started in parallel at boot (default: 4, set to 1 for sequential) |
NB_TIMEZONE |
Default IANA timezone for time-aware features |
NB_HOST_URL |
Public host URL for OAuth redirects |
NB_HSTS |
Strict-Transport-Security value (default: max-age=31536000; includeSubDomains). Set to "" to disable — e.g., when a reverse proxy already emits this header |
NB_CSP |
Content-Security-Policy value (default: default-src 'none'; frame-ancestors 'none'; base-uri 'none'). Set to "" to disable |
Identity & telemetry
| Variable | Purpose |
|---|---|
WORKOS_API_KEY |
WorkOS API key (when auth.adapter: "workos" in instance.json) |
POSTHOG_API_KEY |
PostHog key for anonymous product telemetry |
NB_TELEMETRY_DISABLED |
Set to 1 to disable telemetry (also DO_NOT_TRACK=1) |
Programmatic API
import { Runtime } from "nimblebrain";
const runtime = await Runtime.start({
providers: { anthropic: {} },
store: { type: "memory" },
});
const result = await runtime.chat({ message: "What can you help me with?" });
console.log(result.response);
await runtime.shutdown();
Key Types
interface ChatRequest {
message: string;
conversationId?: string; // Resume existing conversation
model?: string; // Override model for this request
maxIterations?: number; // Override iteration limit
workspaceId?: string; // Target workspace
fileRefs?: FileReference[]; // Attached files for context
contentParts?: ContentPart[];
metadata?: Record<string, unknown>;
}
interface ChatResult {
response: string;
conversationId: string;
skillName: string | null;
toolCalls: Array<{
id: string;
name: string;
input: Record<string, unknown>;
output: string;
ok: boolean;
ms: number;
errorReason?: string;
}>;
stopReason: string;
usage: TurnUsage;
}
Project Structure
src/
├── index.ts Public API exports
├── engine/ Agentic loop (model → tool → repeat)
│ ├── engine.ts AgentEngine class
│ ├── types.ts ModelPort, ToolRouter, EventSink interfaces
│ ├── tasks.ts MCP Tasks client (polling, progress, cancellation)
│ └── cost.ts Token cost estimation by model
├── runtime/ High-level orchestration
│ ├── runtime.ts Runtime.start() → runtime.chat()
│ ├── types.ts RuntimeConfig, ChatRequest, ChatResult
│ ├── tools.ts filterTools (skill-scoped tool filtering)
│ ├── features.ts Feature flags resolution and tool gating
│ └── workspace-runtime.ts Per-workspace connector startup
├── identity/ Authentication adapters
│ ├── provider.ts IdentityProvider interface, UserIdentity type
│ ├── providers/dev.ts Dev mode (no auth)
│ ├── providers/oidc.ts OIDC provider (JWT verification)
│ ├── providers/workos.ts WorkOS provider (OAuth + AuthKit MCP)
│ └── instance.ts Instance configuration loading
├── workspace/ Multi-tenant workspace system
│ ├── workspace-store.ts Workspace CRUD operations
│ ├── types.ts Workspace, WorkspaceMember, WorkspaceRole
│ └── scaffold.ts Workspace initialization helpers
├── connectors/ Connectors, split by the question each part answers
│ ├── runtime/ A live connection's life: lifecycle, startup, auth, probes
│ │ ├── lifecycle.ts Install/uninstall/start/stop state machine
│ │ ├── connection.ts Per-(connector, principal) connection state machine
│ │ └── types.ts ConnectorRef, ConnectorInstance, host manifest meta
│ ├── catalog/ What can be installed: server detail, curated entries, schemas
│ ├── providers/ Who brokers auth and session (composio, smithery)
│ └── gateways/ Hosted-MCP vendors authenticated with one account key
├── api/ HTTP API (Hono framework)
│ ├── app.ts Hono app factory, route registration
│ ├── server.ts HTTP server startup
│ ├── auth-middleware.ts Auth middleware with workspace resolution
│ ├── handlers.ts Route handler implementations
│ ├── events.ts SSE event manager (broadcast, heartbeat)
│ ├── routes/ Modular route files (auth, chat, bootstrap, etc.)
│ └── middleware/ Hono middleware (CORS, etc.)
├── tools/ Tool definitions
│ ├── system-tools.ts System tools factory (search, status, manage)
│ ├── registry.ts ToolRegistry (aggregates MCP sources)
│ ├── workspace-mgmt-tools.ts Workspace management tools
│ ├── user-tools.ts User management tools
│ └── conversation-tools.ts Conversation sharing tools
├── adapters/ Pluggable implementations
│ ├── workspace-log-sink.ts Workspace-level daily JSONL logs
│ ├── console-events.ts Stderr event logging
│ ├── debug-events.ts Verbose debug logging
│ └── noop-events.ts Silent event sink
├── files/ File context extraction
│ └── types.ts File config, supported formats (PDF, DOCX, etc.)
├── skills/ Skill discovery and matching
│ ├── loader.ts File parsing (YAML frontmatter + markdown)
│ ├── matcher.ts Two-phase matching (triggers → keywords)
│ ├── types.ts Skill, SkillManifest, SkillMetadata
│ └── core/ Core skills (always injected, e.g. bootstrap.md)
├── conversation/ Message persistence
│ ├── event-sourced-store.ts Event-sourced store (persists engine events)
│ ├── memory-store.ts In-memory (ephemeral)
│ ├── window.ts History windowing (sliceHistory)
│ └── types.ts ConversationStore interface
├── prompt/ System prompt composition
│ └── compose.ts Multi-layer: identity → core skills → apps → skill
├── model/ LLM provider management
│ ├── registry.ts Provider registry (AI SDK createProviderRegistry)
│ └── stream.ts doStream helper — calls model, emits text deltas
├── telemetry/ Anonymous product telemetry
│ ├── posthog-sink.ts PostHog event mapping
│ └── manager.ts TelemetryManager (opt-in/out, anonymous ID)
└── cli/ Process entry: the serve HTTP API server
├── index.ts Entry point (boots the server)
├── serve.ts HTTP API server boot
└── config.ts nimblebrain.json loading
Local dev orchestration (watch + web HMR) is tooling, not runtime: scripts/dev.ts (bun run dev).
Deployment
Docker Compose
export ANTHROPIC_API_KEY=sk-ant-...
export ALLOWED_ORIGINS=http://localhost:27246 # for cookie-based auth
docker compose up
# Platform: internal only (API), Web: localhost:27246 (UI)
Images are published to GHCR on every release:
ghcr.io/nimblebraininc/nimblebrain-runtime— runtime (Bun; Node 24 builds the in-image connector UIs). Also published asghcr.io/nimblebraininc/nimblebrain(transitional alias).ghcr.io/nimblebraininc/nimblebrain-web— Caddy serving the SPA, proxying/v1/*to the platform
Each release is tagged with the version (e.g. v1.2.3) and the short git SHA. Stable releases also move :latest forward; pre-releases (e.g. v0.4.0-beta.1) do not. Pin to a version tag in production. Pass --build to docker compose to build from source instead.
See Dockerfile, web/Dockerfile, and docker-compose.yml for full config.
Architecture Reference
This section contains detailed internal architecture documentation for contributors.
Token Budget Behavior
maxInputTokens bounds the context of one model call; the runtime windows or compacts history to fit it. A run-wide cap (a task's Max Input Tokens) bounds the run: before each call the engine projects that call's input, and ends the run with stopReason: "max_input_tokens" if the projection would take the run past the cap. Every tool call from earlier steps has already run.
Tiered Tool Surfacing
When total tools ≤30, all are surfaced directly. Above 30 with no skill matched, only nb__* tools are direct (rest via proxy). When a skill matches with allowed-tools, matching tools + system tools are direct. Configurable via maxDirectTools (default 30). Implementation in src/runtime/tools.ts.
NimbleBrain MCP questions
What tools does NimbleBrain MCP provide?
It exposes 12 tools, including nb__status, nb__search, nb__read_resource, nb__set_preferences, nb__manage_tools.
How can I run NimbleBrain using Docker?
You can run it using Docker Compose by setting your ANTHROPIC_API_KEY and creating an instance.json file with the 'dev' auth adapter.
What is a connector in NimbleBrain?
A connector is a remote MCP server that the platform connects to via Streamable HTTP or SSE to aggregate tools into a single namespace.
Can I schedule agent tasks?
Yes, the platform allows you to run agents on demand or on a cron schedule.
How does the platform handle tool access for different tasks?
It uses 'skills' which are markdown files that inject system prompts and scope tool access based on triggers and keywords.