Prepare() is not so slow. If you reuse the same context for each execution the Prepare() method will save time by reusing memory that has already been allocated. Also, if Prepare() is called for the same script function that was executed before it doesn't have to do almost anything.

Don't worry so much about the Prepare() call. It really has to be called for each new script function that you're going to call, as it is the one that sets up the context for that that execution. Without the Prepare() call, the context wouldn't know what to do when you called Execute.

You already seem to be caching the information that should be cached, like the funcId, type, etc. Apparently the context is also reused, rather than created for each call. This is all you need to do, in terms of getting the most out of the script engine.

What you should think about is if you really need to execute the script function for all of the objects each frame. Most of the objects are probably waiting for some kind of trigger before they act, in these cases you could probably skip the execution completely. Even objects that are not just waiting can probably be executed only in intervals, maybe every 5th frame, without any noticeable difference in the behaviour.

Once you have the application up and running, there are some things that you can do to make AngelScript run faster, e.g. turn off multithread support (unless you need it), compile the scripts without line cues, use memory pooling, etc. But don't worry too much about this in the beginning.

If the function is called from the script you can call the global function asGetActiveContext() to obtain the current context. From that you should be able to determine the object instance, either by getting the object pointer from the callstack directly (asIScriptContext::GetThisPointer()), or by using the user data (asIScriptContext::SetUserData()).

You seem to be planning on having the scripts run infinite loops and then run them in parallel. The Context Manager add-on could you help you with that. However, consider that each running script would have to keep its own instance of an asIScriptContext, which would eat a considerable amount of memory (since each holds its own callstack of 4KB by default). Not that this is a problem by itself, but you should be aware of it.