HelixStack

Assemble micro-agents like building blocks. Deploy in seconds.

HelixStack is a zero-code SDK builder that lets developers assemble lightweight Solana agents using modular lattice blocks and deploy them instantly.

🚀 Quick Start

# Install globally (optional)
npm install -g helixstack

# Or use npx
npx helixstack init
npx helixstack simulate ./agent.json

✨ Features

• 🔧 Modular Lattice Blocks: Pre-built, composable units of functionality
• 📝 Zero-Code Configuration: Define agents using simple JSON/YAML files
• ⚡ Instant Deployment: Deploy agents to Solana with a single command
• 🔒 Type-Safe SDK: Full TypeScript support for custom blocks and integrations
• 🎯 Simulation Mode: Test agents locally before deployment
• 📚 Comprehensive Docs: Everything you need to build production-ready agents

🎯 What are Lattice Blocks?

Lattice blocks are modular, composable units that perform specific operations. Think of them as LEGO bricks for blockchain automation:

• LogBlock - Logs structured information
• FilterBlock - Filters data based on conditions
• TransformBlock - Transforms data formats
• Custom Blocks - Extend with your own logic

Chain blocks together to create powerful agent pipelines:

{
  "pipeline": [
    { "type": "log", "params": { "message": "Starting..." } },
    { "type": "filter", "params": { "key": "value", "operator": "greaterThan", "value": 100 } },
    { "type": "transform", "params": { "type": "toSignal" } },
    { "type": "log", "params": { "message": "Complete!" } }
  ]
}

📖 Documentation

• Overview - High-level introduction to HelixStack
• Architecture - Technical architecture and design
• Agents & Blocks - Guide to building agents
• CLI Reference - Complete CLI documentation
• Roadmap - Upcoming features and timeline

🛠️ Installation

Global Installation

npm install -g helixstack

Local Usage (Recommended)

npx helixstack <command>

As a Library

npm install helixstack

import { HelixRuntime, HelixRegistry } from 'helixstack';
import { LogBlock, FilterBlock } from 'helixstack';

const registry = new HelixRegistry();
registry.registerBlock('log', (config) => new LogBlock(config.id, config.params));
// ... use runtime

🎬 Getting Started

1. Initialize an Agent

helixstack init

This creates a sample agent.json file:

{
  "id": "my-first-agent",
  "name": "My First HelixStack Agent",
  "triggers": [
    { "type": "onBlock", "params": { "interval": 10 } }
  ],
  "pipeline": [
    { "id": "log-start", "type": "log", "params": { "message": "Starting..." } },
    { "id": "filter", "type": "filter", "params": { "key": "value", "operator": "greaterThan", "value": 100 } },
    { "id": "transform", "type": "transform", "params": { "type": "toSignal" } }
  ]
}

2. Validate Your Configuration

helixstack validate ./agent.json

3. Simulate Your Agent

helixstack simulate ./agent.json

Output (with timeline):

[00:00.012] Loading agent config…
[00:00.045] Registered 3 lattice blocks.
[00:00.078] [Trigger:onBlock] New block detected at height 295,118,202
[00:00.103] [Block:LogBlock] New block detected, checking conditions...
[00:00.141] [Block:FilterBlock] Filtered 18 raw events → 4 relevant events
[00:00.177] [Block:TransformBlock] Composed signal: BUY_INTENT (confidence: 0.82)
[00:00.203] [Block:LogBlock] Signal ready for execution (simulated).
[00:00.230] Simulation complete: 4/4 blocks succeeded

Options:

• --verbose (default): Show detailed step-by-step execution
• --no-verbose: Minimal output
• --dry-run: Run without executing on-chain actions

4. Deploy (Coming Soon)

helixstack deploy ./agent.json

📁 Project Structure

helixstack/
├── src/
│   ├── core/           # Core engine (Agent, Runtime, Registry, Blocks)
│   ├── config/         # Configuration loading and validation
│   ├── integrations/   # Solana and other integrations
│   └── cli/            # CLI commands
├── examples/           # Example agents
├── docs/               # Documentation
└── package.json

🎨 Examples

Check out the examples directory:

• Simple Agent - Basic block monitoring agent
• Multi-Agent Graph - Complex agent workflows (conceptual)

🏗️ Architecture

HelixStack is built with a modular, extensible architecture:

• HelixAgent: Represents a single micro-agent
• HelixLatticeBlock: Abstract base for all blocks
• HelixRuntime: Orchestrates agent execution
• HelixRegistry: Manages available block types
• SolanaAdapter: Blockchain integration layer (stub)

See Architecture Guide for details.

🔌 Extending HelixStack

Custom Blocks

import { HelixLatticeBlock } from 'helixstack';
import type { HelixContext, HelixResult } from 'helixstack';

export class MyCustomBlock extends HelixLatticeBlock {
  async execute(context: HelixContext): Promise<HelixResult> {
    // Your custom logic
    return { success: true, data: { result: 'custom' } };
  }
  
  describe(): string {
    return 'My custom block';
  }
}

Custom Adapters

import { SolanaAdapter } from 'helixstack';

class MyAdapter extends SolanaAdapter {
  // Extend with custom methods
}

🗺️ Roadmap

• v0.1 ✅ - Local simulation (Current)
• v0.2 - Real RPC connections
• v0.3 - On-chain agent registry
• v0.4 - UI builder

See Roadmap for details.

🤝 Contributing

Contributions are welcome! Areas where help is especially needed:

• Custom block implementations
• Solana integration improvements
• Documentation enhancements
• Example agents
• Testing and bug fixes

📄 License

MIT License - see LICENSE for details.

🔗 Links

• Documentation: ./docs/
• Examples: ./examples/
• Issues: GitHub Issues (coming soon)

💬 Support

• Documentation: Check the docs folder
• Examples: See the examples directory
• Issues: Open an issue on GitHub (coming soon)

---

Built with ❤️ for the Solana ecosystem