Helix Payment Recovery Runtime
A self-healing runtime that diagnoses, repairs, and remembers failures in autonomous-agent payment and API calls.
- Source repo
- usehelix/helix
- Stars
- ★ 817
- Last updated
- 5mo ago
- License
- MIT
- Primary language
- TypeScript
- FA score
- 40/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformCodex · Claude Code
- Cost
- Free software; you pay for model usage
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- A team running on-chain agents with Coinbase, ERC-4337, or x402 payment paths needs a recovery layer for nonce, gas, or transaction-execution errors.
- Not a fit if
- Teams on payment platforms other than Coinbase, Tempo, Privy, or generic HTTP
- Teams unwilling to let auto/full modes change params or move funds
- Source review
- 40/100 · Major gaps 1 safety controls not found
What does this agent do, and when should you use it?
Helix is a self-healing runtime for autonomous agents, focused on payment execution and API-call failures. It wraps an async function and applies a six-stage PCEC flow: Perceive, Construct, Evaluate, Commit, Verify, and Gene. Verified repairs are retained in a SQLite-based Gene Map with reinforcement-learning scoring, so recurring failures can reuse prior strategies. The project exposes @helix-agent/core alongside a Python package, Docker server, REST endpoint, and CLI; its payment adapters cover Coinbase, Tempo, Privy, and generic HTTP. Helix is built as a payment vertical on VialOS Runtime and can be extended to other domains through the PlatformAdapter interface.
A developer wraps an asynchronous operation with wrap(myFunction, { mode: 'auto' }). When the operation fails, an adapter classifies the error, Helix constructs and scores candidate fixes, executes an allowed strategy, verifies the result, and records a successful repair in the Gene Map. Documented strategies include refresh_nonce, speed_up, reduce_request, backoff_retry, renew_session, split_transaction, and remove_and_resubmit. A local service accepts JSON error and platform values at POST /repair; the CLI can scan source with npx @helix-agent/core scan, dry-run a diagnosis with simulate, discover errors with self-play, and consolidate memory with dream. observe diagnoses only, auto changes parameters and retries, and full additionally enables fund-movement strategies.
- A team running on-chain agents with Coinbase, ERC-4337, or x402 payment paths needs a recovery layer for nonce, gas, or transaction-execution errors.
- A product using Tempo MPP, session, or DEX flows wants verified recovery decisions retained in local SQLite memory.
- An application built around Privy embedded wallets needs controlled diagnosis and retry handling for known wallet failures.
- A service engineer needs recovery for outbound API failures such as 429s, 5xx responses, timeouts, connection errors, or authentication failures.
- An engineering team wants to run npx @helix-agent/core scan ./src before CI/CD to identify documented error patterns in a codebase.
- A platform developer needs domain-specific recovery behavior and can implement PlatformAdapter with perceive and getPatterns.
How do you install or deploy this agent?
TypeScript/JavaScript:
npm install @helix-agent/corePython:
pip install helix-agent-sdkDocker server:
docker run -d -p 7842:7842 adrianhihi/helix-serverThe documentation does not specify Node.js or Python versions, nor any credentials or environment variables required for the first invocation.
How do you use this agent?
Minimal TypeScript usage:
import { wrap } from '@helix-agent/core';
const safeCall = wrap(myFunction, { mode: 'auto' });
const result = await safeCall(args);
Start the local server and dashboard:
npx @helix-agent/core serve --port 7842Call the repair endpoint:
curl -X POST http://localhost:7842/repair -H 'Content-Type: application/json' -d '{"error": "nonce too low", "platform": "coinbase"}'Do not use npx helix: the documentation explicitly says it installs an unrelated third-party package.
What are this agent's strengths and limitations?
- PCEC provides an explicit six-stage path from diagnosis through verification and retained repair knowledge, rather than a blind retry loop.
- The SQLite-backed Gene Map records and scores successful repairs, enabling reuse for recurring errors.
- It includes Coinbase, Tempo, Privy, and generic HTTP adapters while exposing PlatformAdapter for new domains.
- It can be consumed as an npm library, Python package, Docker service, REST endpoint, or CLI workflow.
- The documented observe, auto, and full modes make recovery scope selectable; the README also states seven pre-execution constraints and no modification of recipient or calldata.
- Direct payment support is limited to Coinbase, Tempo, Privy, and generic HTTP; other platforms require a custom PlatformAdapter.
- auto changes parameters and retries, while full enables fund-movement strategies, so teams must select a mode appropriate to their risk controls.
- The core depends on VialOS Runtime for PCEC, Gene Map, and learning modules, which introduces that runtime architecture into an adoption.
- No pinned Node.js or Python versions, production authentication details, persistence-location guidance, or high-availability setup are documented.
- The listed benchmarks and error-pattern counts do not include independent validation material beyond the repository's evaluation harness reference.
How does this agent compare with similar options?
Against Sentry/Datadog, Helix is positioned to attempt and verify repairs rather than only detect and report errors. Against simple retries, it selects strategies by error pattern and stores successful repairs in the Gene Map. The README comparison also claims federated cross-agent learning and seven safety checks, making it a fit for paths that need active recovery rather than observability alone.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Helix Payment Recovery Runtime This agent | 40 · Major gaps | Library / SDKFree + model costs | ★ 817 | 5mo ago | TypeScript | Codex · Claude Code |
| Osmedeus — Modern Security Orchestration Engine | 55 · Major gaps | CLIFree | ★ 6.6k | 2d ago | Go | — |
| OpenFang | 51 · Major gaps | CLIFree + model costs | ★ 18k | 6mo ago | Rust | OpenAI API · Claude API |
| Imixs-Workflow Engine | 48 · Major gaps | Library / SDKFree | ★ 419 | today | Java | — |
How does FollowAgents rate this agent?
Why each dimension lost points
The README claims safety constraints, cost ceilings, strategy allowlists, and automatic rollback, but this source sample does not show how they constrain actual payment or fund movement, so least privilege and rollback score 1. The CLI has a planning confirmation option and also --auto-approve to skip it; the SKILL text asks before some actions but also instructs automatic retries and continuation, leaving confirmation incomplete. The SKILL explicitly describes sending event type, protocol number, success flag, and source tag to a telemetry endpoint and claims no PII; the implementation and data handling cannot be verified from this static sample, so transparency and sensitive-data handling score 1. Dependencies are listed without security review evidence, so dependency security scores 1. Telemetry, retries, and the README's fund strategies have external effects, with no demonstrated consent gate for those actions, so external effects score 0. The README provides research-paper and project attribution pointers, but not enough evidence to verify specific code correspondence or maintainer identity, so source attribution scores 1.
The README, package entry points, and CI show many modules and adapters plus a Node 18/20/22 build-and-test matrix. However, the README says the API adapter has 21 patterns while a supplied test asserts 22; test badges and benchmarks are largely self-reported, so self-consistency scores 1. npm, PyPI, Docker, LLM, and telemetry paths are visible, but there is no offline guarantee, availability commitment, or dependency-lock evidence in the packet, so dependency availability scores 1. The CLI wrapper formats errors and supports debug stacks, and the SKILL says to report after failed retries, but failure-message evidence covers only some entry points, so failure messages score 1.
The README targets payment and API agents, multiple payment platforms, and custom adapters, with TypeScript, Python, Docker, REST, and CLI entry points, so audience and scenarios score 2. It names observe/auto/full modes and some safety boundaries, but does not adequately explain how users determine the precise permissions and boundaries of each repair action, so capability boundaries score 1. The SKILL gives protocol triggers and adapter tests cover several error signals, but triggers such as two text-only turns or broad error text may depend on runtime context; the full matching logic is not supplied, so trigger precision scores 1. Several deployment modes and Node versions are documented, but Python, Docker, database, credential configuration, and deployment details are limited in this sample, so environment fit scores 1.
The README has overview, quick start, architecture, installation, FAQ, and roadmap sections; the repository also shows package entry points, workspace scripts, and CI, so information architecture scores 2. Installation methods are clear, although practical configuration detail for Python/Docker and the main TypeScript package is limited, so install notes score 2. Helix, Vial, VialOS, @vial/core, @helix-agent/core, and multiple version references coexist; the CLI package name also differs from the README's main product framing, so naming stability scores 1. Quick-start and FAQ examples are understandable, but the packet lacks verifiable end-to-end operating detail, so examples and FAQ score 2. The README gives a roadmap and mode risk labels but no systematic list of unsupported cases, failure modes, or operating limits, so known limitations score 1. The supplied MIT license text is complete, so license scores 3. There are roadmap and package-version clues, but no changelog or clear release-compatibility policy, so versioning and changelog score 1. A contribution guide is referenced and the license names Helix Contributors, but the sample does not establish maintenance responsibility or an update path, so maintenance responsibility scores 1.
The wrap example, CLI, REST API, and adapter interface describe usable integration and invocation paths, so output usability scores 2. Automatic recovery, memory reuse, and cost savings are central value claims, but the supplied material cannot independently establish their general effect; the stated 90.3% auto-recovery is not directly supported in the packet, so marginal value scores 1. The README gives warm-cache latency and cost comparisons but not enough benchmark method, operating cost, or side-effect detail for deployment tradeoffs, so cost-benefit scores 1.
The README gives benchmark figures and points to an experiments directory, but raw results and methodology are not included, so claim traceability scores 1. There is partial correspondence between README statistics and supplied tests, such as error classification tests; core recovery rates, on-chain benchmarks, telemetry claims, and safety mechanisms lack sufficient corroboration across sources, so cross-source corroboration scores 1. The README presents implemented features alongside strong outcome claims without consistently distinguishing shipped capabilities, experimental results, and inference, so fact-inference separation scores 1.
- Not found in source: disclosed external effectsEstablish which external systems it writes to, sends to or changes, and verify with test accounts or repos before production.
- The SKILL includes curl telemetry requests and writes to /tmp/vial.log; verify whether telemetry can be disabled, the endpoint, retention period, and log access before use.
- The README describes automatic repairs, retries, and fund movement strategies while rating auto mode as low risk; review each strategy, permission boundary, and confirmation mechanism before enabling it for production payments.
- The supplied sample's README API-pattern count conflicts with a test assertion, and recovery-rate and benchmark claims lack accompanying methods and raw results.
Maintain this project? Add the FARS badge to your README
[](https://followagents.com/en/agents/helix)<a href="https://followagents.com/en/agents/helix"><img src="https://followagents.com/badge/helix.svg" alt="FARS review"></a>Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
v2.7.0 v2.7.0 — Agent Payment Intelligence + VialOS Beta
Release notes excerpt
Agent Payment Intelligence New positioning: Helix is not just failure fixing — it's payment intelligence for AI agents. > Predict costs. Optimize execution. Fix failures. Learn forever. What's New - VialOS Beta — --beta flag activates VialOS Runtime integration - GET /vial/status — 13 modules, 5 adapters, PCEC stages - Dashboard "Powered by VialOS Runtime" badge - Without --beta, zero behavior changes - Self-Refine — iterative failure refinement (arXiv 2303.17651) - Prompt Optimizer — DSPy-style prompt self-optimization (arXiv 2310.03714) …View on GitHub ↗ -
v2.6.0 v2.6.0 — Self-Refine + DSPy Prompt Optimizer + API Adapter
Release notes excerpt
What's New Sprint V1: Self-Refine Loop Paper: Self-Refine (2303.17651). When repair fails, PCEC now iteratively refines instead of blind retry: - refine() decides whether to continue + what strategies to exclude - filterCandidates() removes failed strategies from candidate list - Stops after 3 unique failures, same-strategy loop, or max attempts - 100% domain-agnostic Sprint V2: DSPy Prompt Self-Optimization Paper: DSPy (2310.03714). LLM prompt improves automatically over time: - Tracks LLM classification outcomes (correct/incorrect/unknown) …View on GitHub ↗ -
v2.5.0 v2.5.0 — @vial-agent/core Extracted + Comparison Agent
Release notes excerpt
What's New @vial-agent/core — Generic Self-Healing Framework Extracted the universal self-healing engine into its own package. Vial powers Helix and can power any agent: ```bash npm install @vial-agent/core ``` - 34 engine modules: PCEC, Gene Map, wrap(), Meta-Learning, Safety Verification, Self-Play, Federated Learning, Adaptive Weights, Causal Graph, and more - 37 exports: PcecEngine, GeneMap, wrap, AdapterRegistry, evaluate, simulate, all learning modules - VialPlatformAdapter interface: implement for any domain (API monitoring, DevOps, CI/CD) …View on GitHub ↗
FAQ
Can Helix change a payment without my control?
Does a repeated error require another LLM call?
Which non-payment failures are covered?
Can I use it with an unsupported platform?
Thanks — we use this to improve the page.