NucleuX

Nucleux is an intelligent orchestration service designed to streamline crypto transactions by determining the most optimal workflow for user queries.

The system follows a structured pipeline for processing user prompts and executing crypto-related tasks:

1. Initial Processing (Routing Service)

   • User prompts first enter the Prompt Structuring Service
   • This service breaks down complex requests into manageable subtasks
   • The structured workflow then passes through a Validation Service
   • Validation ensures the workflow is feasible and properly structured

2. Action Mapping Service

   • The validated workflow enters the Action Mapping Service layer
   • A Resource Planner analyzes the workflow and determines required resources
   • The Resource Planner interfaces with a Pool of Agents (Bridging, Swapping, Exchange)
   • Task Mapper assigns specific subtasks to appropriate agents based on their capabilities

3. Agent Pool Utilization

   • Any agents deployed on Autonome can be utlised and plugged into the pool.
   • The multi agent orchestrator facilitates collaboration in this dynamic environment where multiple agents not knowing each other can communicate to achieve the end goal
   • For demonstration we deployed three specialized agent on Autonome:
     • Bridging Agent: Handles cross-chain transfers
     • Swapper Agent: Manages token swaps
     • Exchanger Agent: Handles currency/token exchanges

4. Final Output

   • The system processes the workflow through the assigned agents
   • Results are compiled and presented as the final output

This architecture ensures efficient processing of user requests through structured decomposition, validation, and intelligent resource allocation.

Here's a detailed breakdown of how we built this project, including the technologies, architecture, and some interesting hacks we implemented:

🛠️ Tech Stack & Architecture

Core Technologies Used

• Backend: Node.js (Express) for the orchestration logic
• Frontend: React with TypeScript for the UI and interaction plugin
• Blockchain & Agents:
  • Autonome for deploying and managing agents
  • Covalent SDK Zee for fetching on-chain data
• Orchestration Layer: Custom-built using event-driven architecture

🔗 How Everything Fits Together

1. User Query Processing

   • The user submits a request (e.g., “Buy USDC on Gnosis via UPI”).
   • The Prompt Structuring Service (subservice of Routing Service) breaks this into multiple subtasks, each handled by a specialized agent.

2. Workflow Validation & Optimization

   • The Validation Service checks feasibility, correctness, and dependencies before execution.
   • Optimizations like cost minimization and route efficiency are applied.

3. Agent Allocation & Execution

   • The Resource Planner (in the Action Mapping Service) selects agents from the Autonome-deployed pool (Swapping, Bridging, Exchange).
   • The Task Manager assigns each agent a specific responsibility.
   • Agents communicate asynchronously enabling parallel execution.

4. Transaction Execution & Feedback Loop

   • Once the user reviews the plan, and approves the workflow, execution begins.
   • The frontend/plugin dynamically updates the status of workflow

⚡ Cool & Hacky Stuff We Did

1. Dynamic Agent Deployment

   • Instead of hardcoding agents, we made it plug-and-play. Agents deployed via Autonome are instantly available without manual configurations.

2. Cost-Based Routing Optimization

   • The orchestration layer intelligently prioritizes routes with lower gas fees and higher efficiency using Covalent SDK Zee + our custom logic.

3. Frontend as a Plugin

   • Instead of building a standalone UI, we developed a lightweight frontend plugin that integrates into existing dApps for seamless adoption.

4. Multi-Layer Validation for Transaction Safety

   • Instead of a single-layer check, we implemented multi-step validation at:
     • Workflow Structuring
     • Pre-Execution Sanity Checks
     • Agent-Level Validation

🚀 Why These Choices?

• Modularity → Each agent is independent, making the system extensible.
• User Control & Transparency → Users always get full visibility before execution.

This setup makes our multi-agent orchestration service highly efficient, resilient, and developer-friendly.