Autonomous Execution Layer for AI Agents • Pure Go Engine • v1.2.1 Live

Give Any AI Real Hands On Your Computer.

📟 Vibra is the Unix pipe (|). The model is your grep.

Every modern AI excels at reasoning, but lacks safe, deterministic, zero-fail execution. Vibra-Ingenn is the local runtime in pure Go that gives AI models physical hands: the AI compiles a single structured recipe, and Vibra executes the workflow locally in memory with zero external dependencies.

⚡ Get Vibe Engine PRO ($8.99/mo) 📥 Download Free Starter (.exe) Inspect Recipes ↓

< 0.5 ms

Task Primitive Latency

Single-Pass

Workflow Compilation

Pure Go

No Python / No Node Trees

SHA-256

Cryptographic Audit Trail

Vibra-Ingenn Central AI Model Execution Wheel

⚡ Universal AI Integration Hub: Chain local models (Ollama, LM Studio) with frontier cloud models in the same recipe. Model-agnostic by design.

⚡ The Standing Principle: The Model Steps Back

"The AI writes the recipe once, then steps back. The model only comes back if the recipe explicitly asks it to."
Traditional autonomous agents keep models trapped in endless conversational loops, re-sending accumulated history every turn. Vibra-Ingenn separates reasoning from execution. Pure-execution recipes run with zero ongoing token cost. AI-in-the-loop recipes call the model only when the recipe says to — not on every step.

Architectural Paradigm Shift

Our Way vs. Their Way

Why traditional multi-turn chat loops bleed tokens and fail on complex tasks, and how single-pass compilation solves it.

Their Way • The Chat Loop Model

Conversational Context Bleed

💸

Explosive Context Inflation

Because the agent lives in a live chat loop, it re-transmits the entire conversation history (including code generated 5 steps ago) back to the cloud on every single step. Token cost grows with every turn.
🔄

Infinite Circular Hallucinations

Without a deterministic execution roadmap, small models lose context halfway through, editing the same file repeatedly and burning API tokens in circular confusion.
⏱️

Compounding Network Latency

Every single micro-decision requires a 2 to 5-second round-trip network hop to an LLM data center, stretching simple automations to 60+ seconds.

Our Way • Single-Pass Recipe Compiler

Deterministic Local Execution

⚡

Single-Pass Recipe Compilation

The AI ingests the user's prompt once and emits a complete, structured JSON Workflow Recipe. The native Go runtime takes over and executes all tasks locally in RAM — no further model calls needed.
🎯

Local Execution, No Round-Trips

File operations, HTTP calls, scripts, and transformations execute locally without network round-trips between steps. Fast, deterministic, and dependable.
🛡️

Zero Token Reruns (Pure-Execution)

Workflows without an ai_call step can be triggered hundreds of times via shell or cron with zero model involvement and zero token cost. The recipe IS a standalone program.

System Dimension	Traditional Agent Loops (ReAct / AutoGPT)	Vibra-Ingenn (Vibe Engine)
Token Cost Profile	Re-sends full history on every step — cost grows per turn	Single-pass recipe — model touches the task once
Step-to-Step Latency	Network round-trip to LLM on every step	Local execution in compiled Go — no round-trips
Small Local Model Reliability	Small models lose context after a few turns	Small models excel at single-pass JSON output
Portability Across Machines	Hardcoded absolute paths break across machines	Deep template variables: `{{desktop_dir}}`, `{{date}}`
Compliance & Verification	Unverified black box; no proof of file integrity	Cryptographic SHA-256 `audit_receipt.json`
Runtime Dependencies	Heavy Python trees, virtualenvs, pip package conflicts	Single standalone Go binary (Zero Python/Node)

Read the comprehensive "Our Way vs Their Way" breakdown page →

Economic Breakthrough • From the Creator's Journal

The 100-to-1 Failure Tolerance Economics

Traditional AI automation forces an asymmetric penalty: agent loops re-send your entire conversation history on every step, so the cost of experimentation adds up fast. An indie maker running experiments has to be right early or bleed capital.

The Traditional Model

High Financial Pressure

When every task re-sends your full conversation, rapid iterative testing of unproven ideas gets expensive fast. Developers abandon promising automation strategies before they ever find product-market fit.

The Vibra-Ingenn Model

Asymmetric Upside

Single-pass compilation means the model writes the recipe once. Reruns cost nothing — pure execution, no model call. On local models, every run is free. You can test 100 different automated strategies, fail 99 times, and need only 1 winner to generate net profit.

Enabled by: native Go runtime, single-pass recipe compilation, and zero ongoing token consumption on pure-execution recipes.

Model Optimization

The Unix Philosophy for Local 7B Models

Transforming free, open-weight local models into reliable workflow automation engines.

System Insight

Why 7B Models Fail in Chat Loops

Small 7B open-weight models (Llama 3.2 3B/7B, DeepSeek-R1 7B, Qwen 2.5) struggle when forced to act as "monolithic all-in-one conversational agents." In multi-turn chat loops, small models quickly lose schema constraints, hallucinate function names, and break.

The Unix Primitive

Models as grep, cat, and sed

When treated according to the Unix Philosophy — where each model invocation is a single specialized primitive with zero-temperature sampling (temperature 0.0) and schema baking — 7B models operate with near 100% precision. Vibra-Ingenn is the Unix pipe (|) and deterministic shell runtime.

Instant Local Tuning

Custom `vibra-llama` Model

Vibra ships a purpose-built Modelfile (recipes/ai/Modelfile.vibra) with deterministic zero-temperature settings, stop tokens, and the entire recipe protocol baked directly into the system prompt:

ollama create vibra-llama -f recipes/ai/Modelfile.vibra
ollama run vibra-llama "Create a report on my desktop"

Deterministic Schema

The 8-Field Task Contract & Handlers

Every recipe is a clean, committable JSON file that executes physical tasks without external Python scripts.

file_op

Read, write, append, list, delete, or check file existence locally — no network round-trip.

http_request

REST API calls (GET, POST, PUT, DELETE) and web scraping with automated strip_html DOM cleanup.

run_script

Executes whitelisted system binaries, build tools, or PowerShell/Bash scripts safely.

ai_call

Direct bridge to local Ollama/LM Studio or cloud OpenAI-compatible endpoints with payload chaining.

notify

Terminal progress logging, desktop toast alerts, and external webhook dispatches.

transform

In-memory JSON filtering, string parsing, and dotted field extraction without invoking models.

gui_op

Native Windows keyboard and mouse automation for interacting with desktop applications.

browser_op (Upcoming)

Headless Chrome DevTools control in pure Go (bypasses Cloudflare without heavy Python dependencies).

📄 Standard 8-Field Recipe Schema Contract ● VALIDATED CONTRACT

{
  "workflow_id": "automated-data-digest",
  "description": "Fetches data, runs local analysis, and writes summary to desktop",
  "tasks": [
    {
      "id": "fetch_api_data",
      "trigger": "manual",
      "action_type": "http_request",
      "target": "https://api.github.com/repos/golang/go",
      "payload": { "method": "GET" },
      "output": { "store_as": "api_result", "pass_to_next": true },
      "next": "write_summary_file"
    },
    {
      "id": "write_summary_file",
      "trigger": "event:prev_success",
      "action_type": "file_op",
      "target": "{{desktop_dir}}\\go_repo_digest.md",
      "payload": {
        "operation": "write",
        "content": "# Go Repository Status\n\nFetched at: {{date}}\nStars: {{api_result.stargazers_count}}"
      },
      "output": { "log": true }
    }
  ]
}

Production Workflows

Live Recipe Execution Showcase

Explore real, battle-tested recipes that execute locally in milliseconds.

USE CASE: Audit sensitive proprietary code locally without leaking confidential source code to cloud endpoints.

100% Local

Privacy Boundary

file_op + ai_call

Action Primitives

audit_receipt.json

Cryptographic Evidence

// Executable via: .\vibra run .\recipes\system\code_auditor.json
{
  "workflow_id": "code-security-auditor",
  "tasks": [
    {
      "id": "read_source_file",
      "action_type": "file_op",
      "target": "internal/handlers/http_request.go",
      "payload": { "operation": "read" },
      "output": { "store_as": "source_code", "pass_to_next": true },
      "next": "audit_with_local_llm"
    },
    {
      "id": "audit_with_local_llm",
      "action_type": "ai_call",
      "target": "http://127.0.0.1:11434/v1/chat/completions",
      "payload": {
        "model": "vibra-llama",
        "prompt": "Perform OWASP vulnerability audit on: {{source_code}}"
      },
      "output": { "store_as": "audit_notes" },
      "next": "write_audit_report"
    },
    {
      "id": "write_audit_report",
      "action_type": "file_op",
      "target": "{{desktop_dir}}\\security_audit_report.md",
      "payload": { "operation": "write", "content": "{{audit_notes}}" }
    }
  ]
}

USE CASE: Scrapes live news feeds, strips HTML DOM clutter, and generates a clean markdown briefing on your desktop in 220ms.

// Executable via: .\vibra run .\recipes\web\news_digest_pipeline.json
{
  "workflow_id": "hacker-news-intelligence-digest",
  "tasks": [
    {
      "id": "scrape_hn_frontpage",
      "action_type": "http_request",
      "target": "https://news.ycombinator.com",
      "payload": { "method": "GET", "strip_html": true },
      "output": { "store_as": "clean_news" },
      "next": "save_digest"
    },
    {
      "id": "save_digest",
      "action_type": "file_op",
      "target": "{{desktop_dir}}\\hn_daily_briefing_{{date}}.md",
      "payload": { "operation": "write", "content": "{{clean_news}}" }
    }
  ]
}

USE CASE: Deterministically inspects workspace files, identifies modified artifacts, and signs cryptographic hashes to audit_receipt.json.

// Executable via: .\vibra run .\recipes\system\workspace_inspector.json
{
  "workflow_id": "workspace-health-inspector",
  "tasks": [
    {
      "id": "scan_directory",
      "action_type": "file_op",
      "target": ".",
      "payload": { "operation": "list", "recursive": false },
      "output": { "store_as": "dir_tree", "pass_to_next": true },
      "next": "generate_dossier"
    },
    {
      "id": "generate_dossier",
      "action_type": "file_op",
      "target": "workspace_dossier.json",
      "payload": { "operation": "write", "content": "{{dir_tree}}" }
    }
  ]
}

USE CASE: Queries CoinGecko for live Bitcoin and Ethereum telemetry and writes an updated ticker report in 138ms.

// Executable via: .\vibra run .\recipes\web\crypto_pipeline.json
{
  "workflow_id": "crypto-live-ticker",
  "tasks": [
    {
      "id": "get_prices",
      "action_type": "http_request",
      "target": "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum&vs_currencies=usd",
      "payload": { "method": "GET" },
      "output": { "store_as": "prices" },
      "next": "write_ticker"
    },
    {
      "id": "write_ticker",
      "action_type": "file_op",
      "target": "{{desktop_dir}}\\crypto_snapshot_{{date}}.txt",
      "payload": {
        "operation": "write",
        "content": "BTC: ${{prices.bitcoin.usd}} | ETH: ${{prices.ethereum.usd}}"
      }
    }
  ]
}

Zero Configuration

Zero-Touch Local Model Discovery

On startup, Vibra automatically scans your system ports for running AI engines. Zero manual configuration required.

Ollama

Port 11434 • Auto-Detected ✅

LM Studio

Port 1234 • Auto-Detected ✅

vLLM

Port 8000 • Auto-Detected ✅

Jan / LocalAI

Port 1337 / 8080 • Auto-Detected ✅

Multi-Client MCP Integration Snippets

Add to %APPDATA%\Claude\claude_desktop_config.json:

{
  "mcpServers": {
    "vibra-ingenn": {
      "command": "C:\\tools\\Vibra-Ingenn\\vibra.exe",
      "args": ["mcp"]
    }
  }
}

Navigate to Settings → Features → MCP → Add Server:

Name: vibra-ingenn
Type: command
Command: C:\tools\Vibra-Ingenn\vibra.exe mcp

Inside Cline or Roo Code MCP settings:

{
  "mcpServers": {
    "vibra-ingenn": {
      "command": "C:\\tools\\Vibra-Ingenn\\vibra.exe",
      "args": ["mcp"]
    }
  }
}

Prefer a graphical browser interface? Launch the built-in web dashboard with one terminal command:

.\vibra serve
# Launches live dashboard on http://localhost:8990

Security & Enterprise Compliance

Cryptographic Proof of Execution (PoE)

Traditional AI agents act as black boxes with no tamper-evident audit trail. Vibra-Ingenn creates cryptographic certainty:

🛡️ SHA-256 Audit Trail

Every file written or modified by a recipe has its SHA-256 hash automatically calculated and logged into an immutable audit_receipt.json file for enterprise compliance.

🔒 Server-Side HWID Verification

Cryptographic machine-bound token licensing over HTTPS protects intellectual property without triggering aggressive antivirus false positives or locking users out of their local files.

Choose Your Edition

Instant license key delivery, 7-day free trial, and 1-click Windows installer.

Community / Free Edition

Starter Edition

$0 / Forever

The full deterministic recipe engine running 100% locally on your machine against your own local models.

Core Deterministic Execution Engine
Local Model Support (Ollama / LM Studio)
Multi-Step Recipe Chaining & Templates
Local execution only; outbound http_request is Pro-gated

Download Free (.exe)

★ Recommended for Power Users

Vibe Engine PRO

$8.99 / month (or 7-Day Free Trial)

Full professional execution suite with outbound HTTP calls, self-healing retries, and unrestricted multi-step automations.

Everything in Starter, plus:
Instant 1-Click Windows Setup (Setup_Vibe_Engine_PRO.exe)
Automated License Key Delivery (VIBE-XXXX-XXXX)
Outbound HTTP Requests & Web Scraping (strip_html)
Self-Healing Retry Engine & Auto-Repair (RepairTruncatedJSON)
Unrestricted Multi-Step Automation Recipes

⚡ Subscribe to PRO ($8.99/mo)

direct-download-mirrors — windows x64 binaries

Vibra-Ingenn Windows 1-Click Installer

Version 1.2.1 • Standalone Pure Go Executable (No Python Required)

Setup_Vibra_Ingenn.exe Portable .ZIP