AutoHedge Autonomous Fund
Automate market analysis, risk sizing, and Solana trade execution through a specialized multi-agent pipeline.
The README discloses that the system uses market data, an agent pipeline, and Solana trade execution, and it names wallet and model API credentials, giving minimal visibility into data flow and external effects. No permission scope, pre-trade human confirmation, secret storage or redaction policy, network destinations, order limits, cancellation, or rollback mechanism is shown. Dependencies are entirely unpinned, a workflow references a master branch, and no lockfile, audit, or vulnerability mitigation is evidenced. Attribution is partial but inconsistent: the README names The Swarm Corporation, package metadata names Kye Gomez, and the license names Eternal Reclaimer.
The package and CLI names partly agree between the README and pyproject, but the supplied files are materially inconsistent. requirements.txt and pyproject declare different dependency sets; the basic-use example is only a bare command; the quality workflow targets swarms_torch, while CI targets swarms plus documentation and several test directories whose presence is not established. Dependency names describe the intended stack but versions and availability are not secured. No user-facing failure messages, retries, fallback behavior, or exception guidance is provided.
The README identifies developers and automated market-analysis, risk-management, and execution scenarios, and separates Director, Quant, Risk, and Execution roles. It distinguishes currently supported Solana from planned Coinbase and other venues, providing a partial boundary. However, broad claims such as full autonomy and enterprise grade are not refined by configuration or code. Analysis and order triggers, strategy selection, asset selection, and risk thresholds are unspecified. Python 3.10, environment variables, and a CLI entry point give basic environment guidance, but operating systems, wallet format, Solana network, run modes, and deployment requirements are omitted.
The README has a clear progression through overview, features, venues, quick start, architecture, contribution, license, and support. Installation, environment variables, and a CLI entry point are present, but setup, configuration, verification, and secure-deployment instructions are incomplete, and the example has no arguments or output. AutoHedge naming is mostly stable, but workflow references to swarms and swarms_torch conflict with it. There is no FAQ, and limitations are only partially conveyed through roadmap labels and the Beta classifier. The complete MIT text agrees with package metadata, justifying full license credit. Version 0.1.5 is declared, but no changelog or release policy appears. Support and author contacts exist, though inconsistent company, author, and copyright identities leave maintenance responsibility unclear.
JSON output, specialized pipeline stages, logging, market analysis, risk management, and execution could produce usable downstream results and offer value over a single-agent workflow if implemented as described. The supplied evidence contains no output schema, complete example, strategy result, or implementation code, so credit remains thin. API and model charges, chain fees, slippage, latency, resource use, and operational burden are not discussed, preventing a cost-benefit assessment.
The package name, version, CLI entry point, Python requirement, license, and some dependencies are traceable across the README, pyproject, requirements, and LICENSE. Core claims about autonomous trading, real-time analysis, risk-first operation, comprehensive logging, and institutional reliability lack supporting code, configuration, or test contents. Conflicting project paths, dependency lists, and responsible-party names weaken cross-source corroboration. Roadmap items are separated from current support, but promotional superlatives and capability statements are not clearly labeled as goals, design intent, or verified facts.
- The product claims fully autonomous trading with a wallet private key. Do not connect a funded wallet until human confirmation, order limits, network restrictions, secret protection, and recovery controls are evidenced.
- All runtime dependencies are unpinned and the two dependency manifests disagree. Establish a lockfile, dependency audit, and reproducible build process before deployment.
- CI and quality workflows reference swarms, swarms_torch, documentation, and test paths not established by the supplied evidence. Workflow definitions alone are not proof that tests pass or quality controls function.
- Claims such as enterprise grade, institutional reliability, real-time operation, and comprehensive logging lack implementation or test support and should be treated as unverified promotional assertions.
What does this agent do, and when should you use it?
AutoHedge is a multi-agent system for autonomous trading, with full automated execution currently documented for Solana. Its pipeline consists of a Director Agent, Quant Agent, Risk Management Agent, and Execution Agent for thesis creation, quantitative analysis, risk sizing, and order execution. It integrates live market data and can use the Jupiter API for token pricing and search. Recommendations and analysis are emitted as structured JSON, while configurable logging supports auditing and debugging. Its present deployment boundary is narrow: Coinbase remains in development, and other centralized exchanges are only on the roadmap.
The Director Agent generates strategies and trading theses. The Quant Agent performs technical and statistical analysis, after which the Risk Management Agent assesses risk and determines position size before execution. The Execution Agent then generates and executes orders to produce a Trade Output. The system consumes live market data and calls Jupiter API token price and search tools, emits JSON-formatted recommendations and analysis, and records detailed configurable logs. Full autonomous execution is documented for Solana only; no working Coinbase or other centralized-exchange execution path is provided.
- A quantitative developer prototyping end-to-end autonomous trading on Solana can use it to connect research, risk sizing, and execution.
- A trading team that wants every thesis to pass through separate quantitative and risk stages before an order is placed can adopt its staged pipeline.
- An engineering team integrating trade recommendations into another application can consume its structured JSON output.
- An institutional prototype team that needs traceable runs can use its detailed, configurable logs for audit and debugging.
- A contributor building custom strategies or venue adapters can extend the modular framework, while accepting that unsupported venues require new integration work.
What are this agent's strengths and limitations?
- The Director, Quant, Risk Management, and Execution agents have distinct responsibilities, placing analysis and risk review between thesis generation and execution.
- Risk assessment and position sizing explicitly occur before order execution.
- Structured JSON output supports downstream integrations, while configurable detailed logging provides an audit and debugging trail.
- The project documents full autonomous trading on Solana and Jupiter-backed token pricing and search.
- Its modular design is intended to support custom strategies and additional venues.
- Full trading support is currently limited to Solana; Coinbase is still in development, and other centralized exchanges remain roadmap items.
- Autonomous execution requires a wallet private key, creating substantial secret-management and fund-permission risk.
- Installation and startup documentation is sparse, with no minimum Python version, CLI options, deployment topology, or production operations procedure.
- The supplied material provides no evidence of backtesting, paper trading, human approval gates, stop-loss behavior, or failure recovery.
- OpenAI and Anthropic settings are described as experimental, without documented feature coverage, switching behavior, or failure semantics.
How do you install or deploy this agent?
Run the documented package installation command in an environment with pip:
pip install -U autohedgeConfigure the environment afterward. JUPITER_API_KEY is required for Jupiter token price and search tools, and WALLET_PRIVATE_KEY is listed for trading. The experimental-agent configuration also lists OPENAI_API_KEY, ANTHROPIC_API_KEY, and WORKSPACE_DIR="agent_workspace". The source does not specify a minimum Python version, supported operating systems, or a wallet provisioning procedure.
How do you use this agent?
After setting the required environment variables, invoke the documented CLI command:
autohedge
This is the only first-run invocation provided. The currently supported autonomous trading path requires a valid Jupiter API key and a Solana wallet private key. No CLI flags, paper-trading mode, strategy-selection procedure, permission model, or sample run output is documented in the supplied material, so those behaviors should be verified before assigning real funds.