Documentation

Learn how to build and execute AI coding workflows with AgenticNode.

Getting Started

Build your first workflow in 4 steps

1

Open the Composer

Navigate to the visual composer. You will see a canvas where you can design your prompt flow and project context.

2

Add Nodes

Open the node palette on the left sidebar. Drag components like prompts, templates, or context blocks onto the canvas. Each node represents a building block of your prompt workflow.

3

Connect Nodes

Click and drag from one node's output handle to another node's input handle to create edges. Edges define how prompts are composed and how context is folded into your final output.

4

Compose Prompt

Click the Compose button. The prompt is composed client-side. You copy it with a single click, ready to paste into your target agent platform (like Claude Code or Cursor).

Quick start with templates

Instead of building from scratch, load a pre-built template. Visit the Marketplace or append ?template=bug-fix to the composer URL to load a specific template. AgenticNode includes 36 built-in templates covering debugging, code review, testing, security, DevOps, and more.

Open Composer

API Keys & Preferences

Prompts are composed client-side on your local browser. Standard prompt orchestration does not execute agents server-side or bill you for model usage. If you choose to configure API keys in Settings (to enable client-side rendering/validation or legacy runs), these keys are saved in an encrypted vault and only sent to model providers when rendering or running a legacy execution.

Configuring Preferences

  1. 1.Open the composer and navigate to Settings (gear icon in the toolbar).
  2. 2.Enter your default platform (Claude Code, Cursor, Copilot) and choose your preferred tone.
  3. 3.Optionally enter your API key for one or more providers if you want client-side prompt rendering.
  4. 4.Signed-in users can save keys to the encrypted vault. Keys are not persisted in browser storage.

OpenAI

Models: GPT-4o, GPT-4o-mini, GPT-4 Turbo

Key format: sk-...

Get API key

Anthropic

Models: Claude Opus, Claude Sonnet, Claude Haiku

Key format: sk-ant-...

Get API key

Google

Models: Gemini 2.5 Pro, Gemini 2.5 Flash

Key format: AIza...

Get API key

Ollama (Local)

Models: Llama, Qwen, DeepSeek, any GGUF model

Key format: No key needed

Get API key

Ollama (free, local models): Install Ollama on your machine, pull a model (e.g., ollama pull llama3.2), and set the Ollama endpoint in Settings (defaults to http://localhost:11434). No API key required. All computation runs on your hardware.

Available Tools

AgenticNode ships with 14 built-in tools that workflows can reference during prompt composition. Non-AI tools (bash, file operations, git, grep) are resolved client-side. Optionally, you can bring API keys to render dynamic prompt content.

bashShell

Execute shell commands in the project directory. Supports any CLI tool available on the system. Configurable working directory and timeout (default 30 seconds).

file_readFile Operations

Read the contents of a single file. Returns the content (up to 50KB), file path, and size. Used in most workflows to inspect source code before making changes.

file_writeFile Operations

Write content to a file. Automatically creates parent directories if they do not exist. Used by implementation phases to create or modify source files.

file_readerFile Operations

Read multiple files at once by passing comma-separated paths. Returns each file's content and size, or an error if a file cannot be read. Useful for batch code inspection.

file_listFile Operations

List files and directories in a given path. Supports recursive listing up to 3 levels deep. Skips hidden files and node_modules by default. Returns up to 500 entries.

grepSearch

Search file contents using regex patterns. Returns up to 50 matching lines with file paths. Works cross-platform using native grep on Linux/macOS and findstr on Windows.

gitGit

Execute any git subcommand (status, diff, log, commit, branch, etc.). Used by workflows to inspect repository state, create commits, and manage branches.

test_runnerTesting

Run the project's test suite. Defaults to npm test but accepts any test command. Extended timeout of 60 seconds for larger test suites. Returns stdout, stderr, and exit code.

ai_agentAI

Invoke an AI model for a specific task. Supports OpenAI (GPT-4o), Anthropic (Claude), Google (Gemini), and Ollama (local models). Uses your configured API keys. Each call is a standalone prompt with a specialized system prompt based on the agent role.

report_generatorDocumentation

Generate structured Markdown reports from data. Supports templates: bug_fix, security_audit, code_review, performance, and general. Optionally writes the report to a file.

linterCode Analysis

Run ESLint on a project or specific file. Supports auto-fix mode. Returns linting issues in JSON format when available. 60-second timeout for large codebases.

browserSearch

Fetch a URL and return its content. Supports GET and other HTTP methods. 15-second timeout. Returns status code, content type, and body (up to 20KB). Useful for API testing and web scraping.

github_cloneGit

Fetch files or directory listings from a GitHub repository via the API. Supports specific file paths, branches, and authentication with a GitHub token. No local clone needed.

github_prGit

Create a pull request on a GitHub repository. Can optionally create or update files on the branch before opening the PR. Requires a GitHub personal access token.

In addition to the 14 tools above, 7 RALPIVD phase tools (ralpivd_recognize through ralpivd_decision) are registered automatically. Each wraps an AI agent call with a phase-specific system prompt.

RALPIVD Protocol

RALPIVD is AgenticNode's 7-phase prompt orchestration protocol. It structures how composed prompts instruct AI agents to approach complex coding tasks, ensuring systematic analysis before implementation and verification after. The protocol templates instruct the target agent to run in a loop -- if the Decision phase determines that requirements are not met, the agent is instructed to iterate back to an earlier phase.

R

Recognize

Understand the task requirements, constraints, and success criteria. The agent reads the task description and outputs a structured analysis of what needs to be done.

A

Analyze

Examine the codebase, architecture, and context. The agent identifies patterns, potential issues, dependencies, and relevant components in the existing code.

L

Locate

Find the specific files, functions, and code sections that need attention. The agent produces a prioritized list of locations to modify based on the analysis.

P

Plan

Create a detailed, step-by-step implementation plan. Includes what to change, in what order, and how to verify each step. This phase produces an actionable roadmap.

I

Implement

Execute the plan by writing or modifying code. The agent follows best practices, includes error handling, and maintains code style consistency with the existing codebase.

V

Verify

Test and validate that the implementation meets requirements. The agent checks for bugs, edge cases, and regressions. Runs tests and linting to confirm correctness.

D

Decision

Based on verification results, decide whether to: complete (all criteria met), iterate (go back to a previous phase for refinement), or escalate (needs human input).

Using RALPIVD in prompt workflows:Drag RALPIVD phase nodes from the node palette onto the canvas. Connect them in order (R → A → L → P → I → V → D) to output a structured multi-phase instruction, or use a subset of phases. The connections define how the final composed prompt is formatted.

Workflow Templates

AgenticNode includes 36 built-in workflow templates that cover common development tasks. Each template is a pre-configured graph of nodes and edges. Load any template into the composer with one click, then customize it or compose from it.

Bug Fix

Debugging
14 steps~3 min

Code Review

Review
12 steps~2.5 min

Quick Code Review

Review
8 steps~1.5 min

New Project

Project
10 steps~4 min

Refactor

Refactoring
11 steps~3 min

Test Coverage

Testing
9 steps~2 min

Test Generation

Testing
7 steps~2 min

Security Audit

Security
10 steps~3 min

Dependency Audit

DevOps
8 steps~1.5 min

Generate Docs

Documentation
9 steps~2.5 min

Performance Audit

Performance
10 steps~3 min

Release Prep

DevOps
11 steps~2.5 min

API Integration

Integration
7 steps~3 min

Database Migration

Database
7 steps~2.5 min

CI/CD Pipeline

DevOps
8 steps~2.5 min

Code Explainer

Documentation
7 steps~2 min

Browse all templates in the Marketplace. Pro and Team users can create custom templates and publish them for the community.

YAML Format

Every workflow in AgenticNode is represented as a YAML file. You can import and export workflows as YAML, edit them in any text editor, and version control them. The visual composer generates and parses this format automatically.

Workflow YAML structure

name: bug-fix
description: Investigate and fix a bug with tests
version: "1.0"

steps:
  - id: recognize
    type: ralpivd
    phase: recognize
    config:
      task: "Understand the bug report and reproduction steps"

  - id: analyze
    type: ralpivd
    phase: analyze
    depends_on: [recognize]
    config:
      task: "Examine the codebase for the root cause"

  - id: read_files
    type: tool
    tool: file_reader
    depends_on: [analyze]
    config:
      files: "src/index.ts,src/utils.ts"

  - id: implement
    type: ralpivd
    phase: implement
    depends_on: [read_files]
    config:
      task: "Write the fix based on analysis"

  - id: run_tests
    type: tool
    tool: test_runner
    depends_on: [implement]
    config:
      test_command: "npm test"

  - id: decide
    type: ralpivd
    phase: decision
    depends_on: [run_tests]
    config:
      task: "Verify tests pass. If not, iterate."
    on_iterate: analyze

Key fields

  • name -- Identifier for the workflow
  • steps[].type -- One of ralpivd, tool, or ai
  • steps[].depends_on -- Array of step IDs that define prompt composition dependencies
  • steps[].config -- Parameters passed to the prompt block or phase
  • on_iterate -- (Decision phase only) Loop-back metadata indicating where to iterate

Prompt Registry API

Version, deploy, and fetch prompts independently of your application's code deploys. Register a prompt in Prompt Studio, save versions, deploy a version to an environment (production / staging / …), then fetch it at runtime by slug. Promoting a new version updates every caller immediately — no redeploy.

Authentication

Mint a runtime token under API Tokens, then pass it as a bearer token (or X-Api-Key). Tokens are sha256-hashed at rest and shown in full only once, at creation.

http
Authorization: Bearer pk_live_...

Endpoints

  • GET/api/v1/prompts/{slug}?environment=production— deployed content, unrendered
  • POST/api/v1/prompts/{slug}/render— deployed content with {{variables}} substituted server-side

Both accept ?version=Nto pin an exact version, bypassing the environment's deployed pointer. Full schema: OpenAPI spec.

cURL

bash
curl https://agenticnode.io/api/v1/prompts/code-review?environment=production \
  -H "Authorization: Bearer $AGENTICNODE_TOKEN"

JavaScript / TypeScript

A typed, dependency-free client (works in Node 18+, browsers, and edge runtimes) ships at src/lib/prompts-client.tsin the AgenticNode repo — copy it directly:

typescript
import { AgenticNodePromptsClient } from "./prompts-client";

const client = new AgenticNodePromptsClient({ token: process.env.AGENTICNODE_TOKEN! });

const { content, variables, model } = await client.fetchPrompt("code-review", {
  environment: "production",
});

const { rendered, missing_variables } = await client.renderPrompt("code-review", {
  variables: { diff: myDiff },
});

Python

python
import os
import requests

TOKEN = os.environ["AGENTICNODE_TOKEN"]
BASE_URL = "https://agenticnode.io"


def render_prompt(slug: str, variables: dict, environment: str = "production") -> str:
    res = requests.post(
        f"{BASE_URL}/api/v1/prompts/{slug}/render",
        headers={"Authorization": f"Bearer {TOKEN}"},
        json={"environment": environment, "variables": variables},
        timeout=10,
    )
    res.raise_for_status()
    return res.json()["rendered"]


prompt = render_prompt("code-review", {"diff": my_diff})