AgileTaskHeron

First Public Release: 2026-04-08
Last Updated: 2026-09-07

AgileTaskHeron is a task-centered graph engine for:

• Task priority ranking
• Task-Skill-Person bundle generation
• Humanoid robot eligibility and Task-Skill-Robot recommendations

The human workflow uses PageRank and Louvain community detection. The robot workflow ranks Task relationships with PageRank, filters eligible robots from live graph data, and ranks the resulting candidates. No model training is required.

Dynamic robot input supported

Both CPU and GPU backends require only four columns:

src, dst, edge_type, weight

edge_type values are not restricted to a predefined vocabulary. Operator-defined, plant-specific, and non-English values are preserved in the output exactly as supplied.

Task001  -> Vendor_A  -> REQUIRES_VENDOR
Mech001  -> Vendor_A  -> HAS_VENDOR

Task001  -> Skill001  -> TASK_SKILL_REQUIREMENT
Mech001  -> Skill001  -> ROBOT_SKILL_CAPABILITY

Names such as HAS, REQUIRES, MIN, and VERSION are not interpreted by the engine. Task-side and robot-side edge types are paired from actual graph data using:

• Exact dst overlap, such as Vendor_A to Vendor_A
• Shared namespace::value structure, such as Software::required to Software::available
• Weight comparison after compatible destinations are found

If no robot-side correspondence can be inferred for a Task edge type, that edge type remains in the returned requirements but does not reject robots.

The engine does not parse semantic-version ordering from an edge_type name. If version ordering is required, supply a comparable numeric value through weight or normalize the data before analysis.

Node naming rules

• Task identifiers must begin with Task; matching is case-insensitive.
• At least one Task node must exist in src or dst.
• Robot identifiers use the configurable robot_prefix argument; matching is case-insensitive.
• The default robot prefix is Robot.
• Missing Task nodes or nodes matching the configured robot prefix raise ValueError.

result = analyze_robot_task_bundle(
    edges,
    max_robots_per_task=20,
    robot_prefix="Mech",
)

Vendor conditions

The factory examples contain Vendor_A through Vendor_E.

• Every example robot receives a vendor profile edge.
• Every example Task receives a vendor requirement edge.
• Vendor eligibility is inferred from matching destination values, not from the spelling of HAS_VENDOR or REQUIRES_VENDOR.

CPU and GPU backends

Backend	File	Main dependencies
CPU	agile_task_bundle_cpu.py	pandas, NumPy, NetworkX
GPU	agile_task_bundle.py	RAPIDS cuDF, cuGraph

Both backends expose the same analyze_robot_task_bundle() arguments and return structure.

• CPU matching uses pandas and NumPy.
• GPU candidate matching uses cuDF.
• GPU Task PageRank uses cugraph.pagerank(); there is no NumPy PageRank fallback in the GPU backend.

Quick start

CPU:

pip install -r requirements-cpu.txt
python agile_task_bundle_cpu.py robot

from agile_task_bundle_cpu import analyze_robot_task_bundle

result = analyze_robot_task_bundle(
    edges,
    max_robots_per_task=20,
    robot_prefix="Mech",
)

GPU:

conda env create -f environment.yml
conda activate rapids
python agile_task_bundle.py robot

from agile_task_bundle import analyze_robot_task_bundle

result = analyze_robot_task_bundle(
    edges,
    max_robots_per_task=20,
    robot_prefix="Mech",
)

Notebooks:

• Humanoid-Robot-Factory-CPU-Version.ipynb
• Humanoid-Robot-Factory.ipynb

GPU benchmark

Tested on a factory-scale simulated humanoid-robot planning scenario:

• 5,000 simulated humanoid robots
• 1,000 Tasks
• 50 skills
• 5 vendors
• 178,321 total edges
• Approximately 5 million robot-Task candidate combinations
• 1,000 generated Task bundles

Backend	Wall time
CPU	approximately 1 min 21 sec
GPU — AWS g4dn.xlarge, 16 GB GPU, cold start	~ 35 sec
GPU — AWS g4dn.xlarge, 16 GB GPU, warm process	~9.3 sec

This is a future-scale robot workforce simulation, not a claim that a current factory operates 5,000 humanoid robots. At this workload, AgileTaskHeron completes daily operational planning in under a minute. Substantially larger fleets or more frequent analysis may require a larger enterprise GPU configuration.

Main result fields

priority_bundles
robot_task_bundles
task_pagerank_scores
matching_applied
graph_stats

Each Task bundle includes its original requirements, dependencies, eligible robots, rejection counts, robot profiles, and robot-to-Task signals. Observed edge_type strings remain the dictionary keys used to explain these results.

Prior Art

To the best of our knowledge, no existing patent covers the specific combination of PageRank-based task priority ranking and Louvain community detection applied to a Task-Skill-Person heterogeneous graph for automated Agile Task Force formation. Searched across USPTO, EPO, WIPO, KIPRIS, and CNIPA via Google Patents, Espacenet, KIPRIS, and Patentscope. (April 2026)

A second search in September 2026, same offices and the same tools, looked for the robot-factory combination:

• PageRank on a task graph to obtain task order
• Louvain community detection to form Task–Skill–Robot bundles
• Robot eligibility gated jointly by battery level, hardware condition / fault level, software version, and hardware version

No granted patent or published application was found that claims this combination.

License

AGPL v3 — free for research and non-commercial use.

✅ Free to use (No license fee)

• Personal use
• Educational purposes (university courses, student projects, bootcamps, workshops, academic research)
• Non-commercial research and open-source projects

Commercial Version

AgileTaskHeron is available as a production-ready container on AWS Marketplace, with CPU and GPU (RAPIDS-accelerated) editions, deployable on Amazon ECS or EKS.

View on AWS Marketplace →

	This repository	AWS Marketplace
Purpose	Reference / evaluation	Production deployment
Support	Community	Included per license tier
Editions	—	CPU and GPU (RAPIDS)
Deployment	Manual	Amazon ECS / EKS

Special Note for SI Companies
System Integrators integrating a humanoid-line dispatch engine into an existing MES, or productizing that core as their own offering, may inquire about commercial licensing and partnership.

For commercial licensing, enterprise support, or partnership inquiries, please leave a message in Discussions.

Copyright

Copyright © 2026 Klastrovanie Co., Ltd. All rights reserved.