RocketRide

An open source AI meta-harness with the only enterprise-grade C++ runtime, for building, testing and publishing durable agents that scale in production.

Stars
★ 20k
Last updated
today
License
MIT
Primary language
Python

At a glance

Works with
Universal · cross-platform
You'll need
Docker (optional, for container deployment)Python SDK (pip install rocketride)TypeScript SDK (npm install rocketride)VS Code / Open VSX compatible IDE extensionQdrant (optional, for local RAG vector search)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
Backend developers adding an AI feature to an existing Python or TypeScript service: treat document-processor.pipe as a function called once via the SDK.
Main limitation
The official Docker image is amd64 only; Apple Silicon users must run it emulated via --platform linux/amd64, a performance and compatibility cost.
Website
rocketride.ai ↗ set on GitHub
Maintenance
Commits in the last 30 dayslast commit 2026-11-21
Source review
84/100 · Good

What does this agent do, and when should you use it?

RocketRide (rocketride-org/rocketride-server) is an MIT-licensed open source AI meta-harness spanning the full AI Development Lifecycle (AIDLC): build, stage, test, release and maintain. Its core runtime is a native multithreaded C++ engine, driven from a visual canvas inside a VS Code / Open VSX IDE extension where you compose, debug and observe pipelines. Pipelines are portable, version-controllable .pipe JSON files that start from a source node (webhook, chat or dropper), wire together Python-extensible nodes such as LLM providers, vector/graph/SQL databases, OCR, NER and PII anonymization, and return results via a response node. Built-in CrewAI and LangChain support enables multi-agent workflows, backed by deep observability (call-tree tracing, token usage, latency). It ships Python and TypeScript SDKs, an MCP server, and auto-detection of coding agents. Deployment ranges from local runs and Docker/on-prem self-hosting to the managed RocketRide Cloud.

You install the RocketRide IDE extension, start the engine (local, Docker, or built from source), and wire nodes into pipelines on a visual canvas, saved as .pipe JSON files. Pressing ▶ on the source node starts the pipeline, which accepts requests via webhook, chat or dropper and executes a node graph: LLM providers, vector/graph/SQL databases, OCR, NER, PII anonymization, chunking strategies, embedding models, and agent nodes that can invoke other nodes as tools. The example examples/document-processor.pipe takes a PDF or image, extracts text (including text inside images), identifies names, addresses and other personal data, and returns a cleaned copy — fully on local models, so nothing leaves the machine. Applications call it through the Python SDK (pip install rocketride) or TypeScript SDK (npm install rocketride): RocketRideClient.use(filepath=...) loads a pipeline, client.send(token, text) submits input and returns output, and client.terminate(token) ends the run. A built-in MCP server lets coding agents like Claude and Cursor build, modify and deploy pipelines in natural language. While running, the canvas shows call-tree traces, token usage, memory consumption and latency analytics.

  1. Backend developers adding an AI feature to an existing Python or TypeScript service: treat document-processor.pipe as a function called once via the SDK.
  2. Teams processing documents (PDFs, images) containing personal data locally: run the PII anonymization pipeline on local models with no data leaving the machine.
  3. Users building an "ask questions about my documents" RAG pattern: start from rag-pipeline.pipe with a locally running Qdrant vector database.
  4. Engineering teams orchestrating multi-agent workflows (chained agents, shared memory across runs) using built-in CrewAI and LangChain support.
  5. Developers using coding agents like Claude or Cursor who want to build and deploy pipelines in natural language through the built-in MCP server.
  6. Ops-light startups that ship the same .pipe file to RocketRide Cloud and let the managed service handle scaling and uptime.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • docker pull ghcr.io/rocketride-org/rocketride-engine:latest
  • pip install rocketride
  • npm install rocketride
Ports
5565
Environment variables
ROCKETRIDE_APIKEY
Config files
.env
Install notes cover
Linux · Docker

How do you install or deploy this agent?

Install the IDE extension: search for "RocketRide" in the VS Code extension marketplace, or download from the Open VSX Registry. Start the engine by one of:

1) Local (recommended): choose Local in the extension's Connection Manager; the server runs directly in your IDE, nothing to sign up for.

2) Docker:

docker pull ghcr.io/rocketride-org/rocketride-engine:latest
docker create --name rocketride-engine -p 127.0.0.1:5565:5565 ghcr.io/rocketride-org/rocketride-engine:latest
docker start rocketride-engine

The image is amd64 only; on Apple Silicon add --platform linux/amd64 to both pull and create. An engine started without a key accepts any non-empty client value, e.g.:

export ROCKETRIDE_APIKEY=rr_local

3) Build from source: clone the repo and follow CONTRIBUTING.md; the single build tool ./builder manages the C++ toolchain, Python environments and Java/Tika for you.

SDK installs (as needed):

pip install rocketride
npm install rocketride

How do you use this agent?

1) Click the RocketRide extension in your IDE and deploy a server (Local, Docker, or your own hardware).

2) Open the example pipeline examples/document-processor.pipe and press ▶ on the source node; its webhook source waits for input.

3) The extension writes the engine's connection details into a .env in your working folder, which the SDK reads automatically. Call it from code:

import asyncio
from rocketride import RocketRideClient


async def main():
    async with RocketRideClient() as client:
        run = await client.use(filepath='examples/document-processor.pipe')
        out = await client.send(
            run['token'], 'Alice Smith, 12 Elm St, Springfield.', objinfo={'name': 'note.txt'}, mimetype='text/plain'
        )
        print(out)
        await client.terminate(run['token'])


asyncio.run(main())

TypeScript works the same way. Next steps: drop an llm_* node between source and response and add one API key; use rag-pipeline.pipe for semantic search (one LLM key; Qdrant can run locally); use agent-workflow.pipe to add an agent that calls other nodes in a loop. To connect to Cloud instead:

ROCKETRIDE_URI=https://api.rocketride.ai
ROCKETRIDE_APIKEY=your-api-key

What are this agent's strengths and limitations?

Pros
  • The only agent runtime whose core is an enterprise-grade native multithreaded C++ engine, purpose-built for AI/data throughput — a genuine differentiator versus pure-Python frameworks.
  • The whole engine is MIT-licensed and OSI-compliant with no enterprise edition or paywall; the same .pipe runs unchanged on Cloud and on-prem, so pipelines stay portable and lock-in-free.
  • Zero dependency headaches: ./builder manages the C++ toolchain, Python environments and Java/Tika automatically — clone, build, run.
  • Deep observability built in: call-tree tracing, token usage, memory and latency analytics in the canvas, letting you optimize pipelines before scaling.
  • Coding-agent ready: auto-detects Claude, Cursor and more, and ships llms.txt plus an MCP server so agents can build and deploy pipelines in natural language.
Limitations
  • The official Docker image is amd64 only; Apple Silicon users must run it emulated via --platform linux/amd64, a performance and compatibility cost.
  • LLM capabilities require provisioning API keys (the example pipeline defaults to local models only), and semantic search needs you to supply a vector database such as Qdrant.
  • RocketRide Cloud is a paid hosted service that sends your data to the vendor cloud; teams avoiding that path must operate the engine themselves.
  • Adopting the full visual-canvas + .pipe JSON + engine process architecture is heavy if you only need a small embedded agent library.
  • Cluster scaling relies on a Helm chart and your own ops work, and the source provides no benchmarked production-scale performance figures.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
RocketRide This agent 84 · Good — ★ 20k today Python —
VoltAgent 50 · Major gaps CLIFreemium ★ 11k 15d ago TypeScript ChatGPT · OpenAI API · Claude API
XERJ 65 · Some gaps CLIFree ★ 19k 1d ago Rust Claude Code
LlamaAgents 59 · Major gaps Library / SDKFree + model costs ★ 469 today Python —

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Good
84/ 100 5-point scale 4.2 / 5
Trust 24/29
Reliability 12/14
Adaptability 15/18
Convention 16/18
Effectiveness 12/13
Verifiability 5/8
Why each dimension lost points
Trust24 / 29 · 4.1/5

Least privilege and user confirmation are strongly evidenced: CI workflows default to contents:read with per-job elevation, actions pinned by SHA; skills enforce hard gates (waiting = end of turn, .context/GATE_STATE.md prevents auto-approval after context reset), a cost gate (Gate C.5), and blast-through prevention. Secret handling is explicit: only ${ROCKETRIDE_*} env references, out-of-band credential configuration, secret scanning with push protection. Deductions: external effects (tool nodes, cloud billing) are gated but static evidence is limited; rollback is barely addressed (one line about version-controllable JSON pipelines); attribution — LICENSE/AGENTS.md reveal the project is really Aparavi, a dual RocketRide/Aparavi identity the README does not foreground.

Reliability12 / 14 · 4.3/5

Skills and docs are highly self-consistent: a clear three-layer fallback ladder (MCP/shim/offline index), no node invented from memory (must cite the index); failure-message handling is exemplary — verbatim quoting required, ERROR_TABLE maps errors to cause and owning phase. Deductions: the bundled node index 'can drift from what a live engine has registered' — a known availability/static-dynamic gap; no CHANGELOG-style version consistency evidence in the sample.

Adaptability15 / 18 · 4.2/5

Audiences are well segmented (local users, contributors, cloud users, coding agents) with a glossary, stepped examples, and diagrams; skill frontmatter descriptions precisely bound trigger scenarios. Deductions: capability boundaries are disclosed only piecemeal (amd64-only image, index drift, empty traces at traceLevel=none) rather than in a systematic limitations doc; environment fit — the README states running the SDK outside the project folder 'falls back to RocketRide Cloud', a behavior that may surprise users.

Convention16 / 18 · 4.4/5

Excellent information architecture: AGENTS.md is the single source of truth for task routing; doc-contract updates in the same change are enforced by CI (docs:check, validate-node-readme). Install notes cover four paths (IDE/Docker/local/cloud), naming (.pipe, rocketride-*) is stable, and contribution/security/governance docs are complete. Deductions: known limitations are scattered rather than centrally disclosed; no CHANGELOG file is shown, and the relation between version 3.6.0 and the 3.1.x supported-versions table is unexplained in the sample.

Effectiveness12 / 13 · 4.6/5

Output usability is strong: pipelines are diffable JSON, validate() acts as the compiler, deep observability (traces/tokens/latency); marginal value lies in schema-driven configuration plus enforced validation genuinely reducing hallucinated node/field risk. Deduction on cost/benefit: the SDK silently 'falls back to RocketRide Cloud' when run outside the project folder — an implicit billing path; Gate C.5 mitigates, but the default fallback itself is not surfaced.

Verifiability5 / 8 · 3.1/5

In-repo traceability is good (nodes must cite the index, validate results quoted verbatim, CI gates reference concrete issue numbers like #1754/#1828). Deductions: marketing claims are mixed with facts — 'the only enterprise-grade C++ runtime', '0/24 on Haiku' (methodology/scope unstated), and 'battle-tested' cannot be verified within the packet; cross-source corroboration is limited to internal consistency, and the publisher is unverified.

Risks and how to mitigate them
  • Publisher identity is unverified; LICENSE shows copyright by Aparavi Software AG alongside the RocketRide brand — confirm the actual operating entity before adoption.
  • The SDK client falls back to RocketRide Cloud (a billed endpoint) when run outside the project folder; if you do not intend cloud use, always run from the local directory and set ROCKETRIDE_URI explicitly.
  • Docker images are amd64-only (add --platform linux/amd64 on Apple Silicon); the bundled node index can drift from what a live engine registers — always confirm against live schemas.
  • Performance and reliability claims ('the only enterprise-grade C++ runtime', '0/24 on Haiku') are vendor assertions without independent verification.
  • The relation between the supported-versions table (3.1.x) and the package version (3.6.0) is unexplained in the sample; verify security support scope before deploying.
  • This is a static review of a file sample only; no execution was performed, and validate()/run-result correctness is outside the scored scope.
Evidence confidence: Low Reviewed Nov 21, 2026 Reviewed revision ac95345cd331
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/rocketride-server.svg)](https://followagents.com/en/agents/rocketride-server)
<a href="https://followagents.com/en/agents/rocketride-server"><img src="https://followagents.com/badge/rocketride-server.svg" alt="FARS review"></a>

FAQ

Which port does RocketRide use?
The install notes on this page use port 5565 (for example http://localhost:5565). If the project lets you change the port, its README explains how.
Is RocketRide open source?
Yes. The source code is on GitHub (rocketride-org/rocketride-server) under the MIT licence.
Is RocketRide safe to use?
FollowAgents' FARS review (Nov 21, 2026) scored RocketRide 24/29 on trust and safety. None of the eight safety controls the review checks for was missing outright.
Is RocketRide still maintained?
Yes. The latest commit on GitHub is from 2026-11-21, within the last 30 days.
Who makes RocketRide?
RocketRide is published on GitHub by the account rocketride-org. FollowAgents has not verified which person or company is behind that account.
What is RocketRide's official website?
The project's GitHub repository lists https://rocketride.ai as its website. That link is set by the repository owner; the source code itself is on GitHub (rocketride-org/rocketride-server).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts