Documentation

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

Getting Started

Build your first workflow in 4 steps

1

Open the Editor

Navigate to the visual editor. You will see a canvas where you can drag and drop nodes to build your workflow.

2

Add Nodes

Open the node palette on the left sidebar. Drag RALPIVD phase nodes, tool nodes, or AI nodes onto the canvas. Each node represents one step in your workflow.

3

Connect Nodes

Click and drag from one node's output handle to another node's input handle to create edges. Edges define the execution order of your workflow.

4

Run the Workflow

Click the Run button. The Glass Window will open, showing every step's execution in real time -- tool calls, AI responses, token usage, and timing.

Quick start with templates

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

Open Editor

API Keys

AgenticNode does not charge for AI model usage. You bring your own API keys and pay providers directly. Saved keys live in the encrypted server-side vault, and normal editor execution loads them server-side.

Configuring API keys

  1. 1.Open the editor and navigate to Settings (gear icon in the toolbar).
  2. 2.Enter your API key for one or more providers.
  3. 3.Select your default model. This model will be used for all AI agent steps unless overridden per-node.
  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 invoke. Non-AI tools (bash, file operations, git, grep) work without API keys. AI-dependent tools (ai_agent, RALPIVD phases) require a configured API key.

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 autonomous execution protocol. It structures how AI agents approach complex coding tasks, ensuring systematic analysis before implementation and verification after. The protocol can iterate -- if the Decision phase determines that requirements are not met, it loops back to an earlier phase (up to a configurable maximum, default 5 iterations).

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 workflows:Drag RALPIVD phase nodes from the node palette onto the canvas. Connect them in order (R → A → L → P → I → V → D) or use a subset of phases for simpler tasks. The Decision node can loop back to any earlier phase by connecting its output to that phase's input, enabling iterative refinement.

Workflow Templates

AgenticNode includes 17 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 editor with one click, then customize it or run it as-is.

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 with git. The visual editor 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 must complete before this step runs
  • steps[].config -- Parameters passed to the tool or phase
  • on_iterate -- (Decision phase only) Which step ID to loop back to if iteration is needed