Industrial UR10 arm performing a mixed-product kitting task – picking colored bottles from a conveyor and assembling them into a tray alongside branded packaged goods on a cart. Generated end-to-end from a single sentence of natural-language description. Industrial pick-and-place task generated automatically from a short natural-language description and validated in simulation before deployment to the production robot.
Value Proposition
AI-based Robotic Task Setup is an AI-powered programming environment for industrial robot integrators and small-batch manufacturers that turns a brief natural-language description of a pick-and-place task into a fully tested, deployable robot control program. By combining state-of-the-art AI coding agents with a robotics framework and automated simulation-based verification, the system reduces the time required to set up a new robot task from days or weeks of expert engineering work to under two hours of natural-language interaction – typically more than an order of magnitude faster – while producing code that runs predictably and offline on the production robot, with no run-time dependency on cloud AI services.
Business and Innovation Perspective
Challenge
Industrial robot arms are excellent at repetitive, precisely scripted tasks, but in modern Industry 5.0 settings – small-batch and high-mix manufacturing, frequent product changes, custom kitting, agile production lines – the bottleneck is no longer the robot itself, but the cost and time required to **re-program** it for each new task. Re-programming a robot for a new variation of a pick-and-place task (different objects, layouts, sorting rules, container types) typically takes a robotics engineer days to weeks per task and is a major barrier for SMEs that cannot afford a permanent robotics integration team. The gap between how a production engineer would naturally describe a task and the precise specification, geometry, motion sequencing and success-criteria coding required to make it run reliably is the dominant cost driver in flexible robotic automation.
Existing alternatives
Current industry approaches each have substantial drawbacks. Manual hand-coding by a robotics engineer is accurate but slow, expensive and dependent on scarce expertise. Teach-pendant programming and lead-through demonstration work for very simple, fixed-geometry tasks but do not generalise to randomised initial conditions, mixed object types or attribute-based sorting. Vendor-specific graphical task editors lock the customer to a single robot brand and still require manual design of every task variant. End-to-end imitation or reinforcement learning is promising in research but needs large amounts of training data per task and produces opaque policies that are hard to certify for industrial QA. Driving the robot in real time directly from a cloud LLM places the production line at the mercy of an external service and offers no compile-time guarantees on the generated behaviour.
EDI solution and unique value
The EDI AI-based Robotic Task Setup technology generates standalone, offline-runnable robot control code, not a dependency on a live AI service. A user – including a non-programmer – describes the task in one or two natural-language sentences. An AI coding agent, operating inside an EDI-developed robotics framework, produces the simulation configuration, the robot’s control program and automated success-verification checks. The system then validates the generated code in three simulation tiers – a fast offline check, a rapid visual preview, and full physics simulation in NVIDIA Isaac Sim – automatically detects failures, and iteratively repairs the code until it passes randomised robustness tests across multiple seeds.
Four examples of distinct generated pick-and-place tasks: kitting branded products and colored components into a tray, lining up bottles on a cart, mixed kitting of bottles and packaged goods, and packing soup cans into wooden boxes – each produced from a short natural-language description.
A growing library of generated tasks: kitting, line-up arrangements, mixed-product packaging, container packing. As more tasks are added, new variants can be produced by recombining proven patterns rather than starting from scratch – making the system progressively more efficient over time.
The unique combination of (a) a domain-specialised robotics framework with reusable building blocks, (b) automated success-checking that closes the agent’s debugging loop, and (c) a fast offline verification layer that runs in under one second, is what allows the technology to deliver, simultaneously, non-expert usability, fast turnaround, measurable reliability and offline deployability – none of the existing alternatives offers all four.
Quantified improvements measured on a benchmark of 20 generated pick-and-place tasks of increasing complexity:
| Parameter | Industry baseline / alternative | EDI AI-based Robotic Task Setup |
| Time to set up a new pick-and-place task variant | Days to weeks (expert engineer) | < 2 hours of natural-language interaction |
| Required user expertise | Robotics / control engineer | Production engineer with no robotics coding |
| Offline-test success rate (200 randomised runs, 20 tasks) | n/a – alternatives lack automated verification | 100% |
| Rapid-validation success rate (100 simulation runs) | n/a | 97% |
| Full-physics simulation success rate (60 runs) | n/a | 80% (without motion-planning extension) |
| Run-time dependency on external AI service | n/a (manual code) / required (online-LLM) | None – generated code runs fully offline |
| Re-use of previously implemented tasks for new variants | Manual copy-paste, error-prone | Automatic – agent recombines existing patterns |
Technology readiness level (TRL)
TRL 4–5 – Technology validated in a relevant simulated industrial environment (NVIDIA Isaac Sim, simulated UR10 industrial robot arm), with statistically supported success rates over 20 representative pick-and-place tasks across four difficulty categories.
Developed within AIMS5.0 (Advancing Integrated Manufacturing Systems (Industry 5.0)), supported by the Chips Joint Undertaking and its members, with top-up funding from National Funding Authorities of participating countries. Grant agreement No. 101112089.
Technical Specification
Operating principle
High-level architecture: a short natural-language description is turned into validated robot control code by an AI coding agent that draws on a structured task framework. Generated programs are automatically tested in simulation, and any failures are fed back to the agent for self-correction.
High-level architecture of the system.
The user enters a short natural-language description of the task. An AI coding agent, working inside an EDI-developed robotics framework, generates the corresponding simulation setup, the robot’s control program and the automated checks that confirm the task is performed correctly. The generated program is first validated in a fast offline mode, then in a rapid visual preview, and finally in full physics simulation in NVIDIA Isaac Sim, with each task replayed under multiple randomised initial conditions to confirm robustness. When a check fails, the diagnostic output is fed back to the agent, which iteratively refines the code until the task passes – without further user intervention. The resulting program is standalone and runs offline on the production robot controller.
Empirical validation on a set of 20 generated pick-and-place tasks across four complexity categories – basic sequential pick-and-place, attribute-based routing, sorting with stacking, and complex multi-feature scenarios – gave a 100 % success rate in offline testing, 97 % in rapid visual preview, and 80 % in full-physics simulation. The remaining full-physics failures are attributable to the absence of collision-aware motion planning, which is on the roadmap.
Parameters
| Parameter | Value / Description |
| Input modality | Natural-language text (English), free-form, 1-3 sentences typical |
| Supported task class (current) | Industrial pick-and-place with attribute routing, sorting, stacking, container targets |
| Robot platform (validated) | Universal Robots UR10 (6-DOF arm), simulated in NVIDIA Isaac Sim |
| Simulation backend | NVIDIA Isaac Sim 5.1, GPU-accelerated physics |
| Verification tiers | Offline test (CPU, < 1 s/run); rapid visual preview (~seconds/run); full physics (minutes) |
| Task-setup time (per new task variant) | Typically < 2 hours of natural-language interaction, end to end |
| Run-time dependency on AI at deployment | None – generated code is standalone and runs offline on the production robot controller |
| Operating system | Linux (Ubuntu 22.04 validated), x86-64 with NVIDIA GPU |
| Interfaces | Python API for the framework; ROS-compatible deployment of generated control programs |
Coorperation Modes
We see three transfer paths for partners interested in the technology:
- Licensing – a non-exclusive or exclusive licence to use the EDI task framework and verification layer in the partner’s own products or internal robotic-integration workflows, including the right to extend and customise the framework for the partner’s robot platform and task domain.
- Contract research / joint development – adaptation of the technology to the partner’s specific robot model, end-effector, sensor stack, asset library and task family; integration with the partner’s MES/ERP and quality-assurance pipelines; extension to additional task classes (e.g. assembly, kitting, machine tending) and to additional industrial robot vendors.
- Assignment – outright transfer of the underlying intellectual property (know-how) to a strategic partner under a negotiated agreement.
EDI is open to combining the above (e.g. a contract-research engagement followed by a licence) and welcomes early conversations with system integrators, robot OEMs, and end-users in small-batch and high-mix manufacturing.
Funded within the AIMS5.0 project (Chips JU, grant agreement No. 101112089).
