Code generation for multiple platforms
It doesn't matter which technique you use, you'll face three potential problems:

Using "the same (orchestration-driver) data" across all N targets.
There will be a preferred way for each target to represent that data.
You can choose a lowest common denominator (e.g., text or XML) at the price of making the target engines clumsier to write
Finding equivalent effect in each of N target.  Imagine you need "eval" (I hope not) in each target; even if they appear to have similar implementations, some detail will be wrong and you'll have to work around that
The performance of one or more of the targets is poor.

If you code your own implementation, you can more easily overcome 2) and 3).  
If you generate code, you have more flexibility to change how a particular target runs.  If you use simple text-based "templates" to generate target language code, you won't be able to generate very efficient code; you can't optimize what you generate.    If you use a more sophisticated code generator, you might be able to generate/optimize the result.
Its hard to tell how much trouble you are going to have, partly because you haven't told us what this engine will do or what the target langauges are.  It will also be hard to tell even with that data; until you have a running system you can't be sure there isn't a rude surprise.
People use sophisticated code generation techniques when they are facing the unknown because that maximizes flexibility and therefore makes it easier to overcome complications.
People use simpler code generation when they don't have the energy to learn how to use a sophisticated generator.   If they are lucky, no problems arise and they win.    If this experiment isn't a lot of work, then you should try it and hope for the best.
I'm designing an orchestration engine which can automate tasks within multiple environments: JavaScript web UIs, Python webservers, and c runtimes. One possible approach to is to write the orchestration core in each language. That seems brittle as each new engine feature will need to be added to each supported language (and bugs will have to be resolved multiple times, all while dealing with different idioms in each language). Another approach would be to write the core once in the lowest common denominator language (possibly c) and then wrap it in the other languages. But, I think deployment of the compiled libraries to browsers would be a nightmare if not impossible. So, another option I'm considering is templates and code generation. The engine could then be written once (probably in Python), and the workflows compiled to each target using jinja templates.
Does this last approach sound feasible? If I go that route, what pitfalls should I be aware of? Should I suck it up and write the engine three times?