Maybe this part of the answer helps. It was sufficient for many tasks, but fails at some reasonable problems.

A permutation action is a multi-set of conjugacy classes of subgroups of a group. The degree of the action is the total of the indices of representatives from each class (with multiplicity). The kernel of the action is the intersection of all the classes, or equivalently, the intersection of the normal cores of the representatives from each class.

If you have a collection of subgroups, organize them into conjugacy classes, sort them by their normal core (first by size, then by actual subgroup). For each normal core (especially starting with the small ones), choose the largest subgroup (smallest index) with that core. These largest subgroups are your ingredients.

Now roughly speaking try all combinations: compute the index and the kernel, and keep the best one, save any improvements to disk if you plan on letting this run for a while.

If you don't have a collection of subgroups handy, then you need to use group-specific ideas to get yourself some. If the Fitting subgroup is small, then cores are unlikely to be a real problem, so you just want big subgroups that are cheap. For small (≤10^{7} or so) groups, you can compute local subgroups pretty cheaply.

If the Fitting subgroup is large or weird, then cores will be plentiful and weird or at least hard to avoid (a particularly awful situation is a unique minimal normal subgroup of order 2). In this case, one computes a full subgroup lattice. You can use recent versions of magma to get a fast answer, but be sure to read the changelogs to make sure you weren't affected by a missing subgroup.

At any rate, in practice this method failed to handle some of the perfect groups in the perfect group library. Perfect groups with large Fitting can require very large permutation representations, but the theoretical lower bounds were often quite a bit lower than what I was able to achieve in practice.

If your groups are finitely presented and you have no good starting permutation rep, then you may find that coset enumeration is faster for finitely presented groups than for millions-of-points permutation groups. In other words, typically speaking you start with some permutation representation, because it is going to be faster than any finite presentation. However, for really bad permutation representations (close to regular), you may find coset enumeration is much faster. In particular, finding the index or core of a subgroup might be faster to use ACE than to use permutation group code.

If your groups are small and solvable with low sectional rank, just compute the subgroup lattice and sort.