DYNAMIC AI SKILLS PLATFORM
Build, validate, version, and execute dynamic AI skills on a graph-first agent runtime.
Every tool call is restricted to authorized schemas, write actions require explicit Human-in-the-Loop approval protected by single-use idempotency tokens, and every AI call auto-fails over across 12 free models.
// Click [ RUN SIMULATION ] to test real-time agent execution pipeline.
Skill: CustomerSupportAssistant (Published v1)
Permitted Tools: ["calculator", "document_search", "mock_task_creator"]
Actions Requiring Approval: ["mock_task_creator:create"]
Plan Generation
The LLM is one dependency of one node. It emits a deterministic, schema-validated execution plan — never touches tools directly.
Tool Authorization
Every planned tool must exist, be enabled, and be listed in the skill's allowedTools — anything else is rejected before it can run.
Step Routing
The graph routes step-by-step via conditional edges: approve, execute, or finish — the plan is walked deterministically.
Tool Execution
Each step runs through the tool registry with retry handling. Tool calls and their outputs are persisted for full auditability.
HITL Pause
Write actions flagged for human review park the run in PAUSED_FOR_APPROVAL. A single-use idempotency key guarantees the response happens once.
Output Assembly
Collected step results are assembled into the final output and persisted alongside the full node timeline.
{ "status": "COMPLETED", "provider": "groq/llama-3.3-70b-versatile", "durationMs": 1842, "maxSteps": 10, "plannerOutput": { "reasoning": "Resolve the refund first…", "requiredTools": ["calculator"], "steps": 3 }, "nodeTimeline": [ "planner → permission → tool_selection", "→ tool_execution → finish" ] }
- The LLM is a node dependency, not the system. The runtime walks a deterministic LangGraph — the same plan executes identically with any provider.
- Every step is persisted. Planner output, provider used, duration, node timeline, and tool calls survive the run for replay and audit.
- Failure is handled like any node. Provider failures, timeouts, unauthorized tools, and step-limit breaches all resolve to explicit terminal states.
Schema-Validated Skill Definitions
Define custom agent skills with strict JSON Schema inputs and outputs, instructions, few-shot examples, and maximum execution step boundaries.
LangGraph Execution Engine
Skills execute deterministically through independent nodes — planner, permission, selection, execution, approval, finish — each writing to strongly typed state.
Strict Tool Authorization
Agents operate strictly within allowed tools. Unpermitted tool requests are intercepted and rejected at the permission node before execution.
Single-Use Idempotency Approval Locks
Write actions automatically pause agent execution into a pending state. Approval consumes a single-use token — enforced atomically, so a key can never respond twice.
Draft & Published Version Control
Publish drafts into immutable numeric versions (v1, v2, v3). Editing a published skill auto-rotates a fresh draft — published versions never change.
Multi-Provider Router with Circuit Breakers
12 free models across Groq and OpenRouter are tried in order. Failures trigger adaptive cooldowns (429 → 60s, 5xx → 30s, 404 → 10min, bad key → vendor park).
Safely evaluates mathematical expressions and formulas.
Mock vector and text query search over internal knowledge base.
Queries structured customer data records and database entities.
Creates tasks & tickets. Requires HITL human approval before execution.
Single-Use Idempotency Tokens
Every approved write action generates a single-use token, enforced atomically in the database — replays and concurrent duplicates are blocked.
Multi-Tenant Isolation
Strict PostgreSQL tenant boundaries isolate skills, versions, executions, and approval records per user account.
Hard Execution Step Limits
Enforces maximum step boundaries (e.g. 10 steps) to prevent infinite loops, runaway API costs, and resource leaks.
LLM Circuit Breakers
A single model failure never fails a run — the router parks it in an adaptive cooldown and transparently moves on to the next.
Atomic Database Writes
Skill creation, draft rotation, publish, and execution persistence commit in single transactions — a crash can never orphan data.
Full Audit Trails
Every mutation writes a structured log and an audit row (SKILL_PUBLISHED, APPROVAL_GRANTED, …) traced back to the acting user.
How does Human-in-the-Loop (HITL) approval work?
When an agent executes a tool specified in actionsRequiringApproval, execution pauses in a pending state. Users review the payload and approve or reject it.
What prevents duplicate write execution?
Every approved write action carries a single-use idempotency key, enforced atomically. Once consumed, replaying the same key — even concurrently — is rejected.
Can agents call unauthorized tools?
No. Tool availability is restricted to the exact allowedTools list defined in the skill schema. Unpermitted tool calls are rejected at the permission node.
What happens when an LLM provider goes down?
Nothing breaks. The router parks the failed model in a cooldown and transparently retries the next of 12 configured models across Groq and OpenRouter.
Can I trace how an execution ran?
Every run persists its planner output, serving provider, duration, node-by-node timeline, and tool calls — inspectable in the execution trace view.
How does skill version control work?
Skills start as a Draft. Publishing creates an immutable numeric version (v1, v2), and editing a published skill auto-rotates a fresh draft so published versions never change.