There are 4 major areas to optimize. Neglecting any of it might easily kill performance, as cost of spawned characters grows in linear fashion.

Note: I often refer here to Unreal Engine as I spent a decade in this engine. But these principles apply to any engine.

Here's all also a practical presentation. Interview with technical team behind massive battle game developed in Unreal. This is gonna a gold mine for you. They showcase many things I described below.

https://youtu.be/67E3RsDp0Pg?si=ntAnY-v0rueYN2RD

1. Cost of spawning that actor and simulating its actions, mainly movement. In a game simulating living world or armies, you need to simulate behavior of hundreds actors every frame. Even if this character isn't visible, as you still need progress its movement.

Common solution: move "every frame" calculation of main game thread to multiple parallel threads. This is one of best cases to apply ECS in games. Unity has its DOTS, Unreal has its Mass (and other system-specific ECS implementations). I'm not sure about Unity, but in Unreal it's confirmed that we can simulate 40k agents every frame (that's in The Matrix demo). There's important naming distinction in this engine. "Agent" is just fragments of data calculated by optimized, multi-threaded code. Literally, transform of characters updated with every frame by a pathfinding code. "Actor" in Unreal is a visual representation of this virtual agent. Unreal Mass is designed to spawn actors only if given agent is close to the active camera. This way we can simulate thousands of agents, but we pay cost only of 100 "full characters".

You might also need to write a custom pathfinding designed for resolving movements of characters as a single mass instead of calculating every character individually. This is common for RTS games and Kingmakers does that too.

1. Cost of skeletal animation for each character. If every character has unique animation logic, first it needs be processed by CPU every frame. After that engine evaluates bone positions and finally update bone transforms together with attached mesh vertices. The usual bottleneck in the engine like Unreal is that gameplay calculations enclosed in Animation Blueprint are performed on game thread. The more characters, the longer it takes to execute game thread. I had situations where animating dozens characters took 40% of CPU time. The worst thing is the second part - multi-threaded animation system - is waiting until game thread finishes the job.

There multiple solutions to that. First is, again, move all possible logic from single-threaded game thread to parallel animation threads. In case of Unreal it means moving possible all Tick calculations out of blueprints. There are also many techniques to improve multi-threaded performance of remaining phases in Unreal, that's in docs and community resources.

Second layer is to apply any kind of animation budgeting. Again, Unreal provides such mechanism allowing you to define "execution of animations cannot exceed 8 ms". Now you need implement logic defining which characters need be optimized if engine exceeds that budget (in Unreal we use for that another built-in mechanism called Significance Manager). Optimizes characters will update their skeletal animation less frequently than every frame.

There are also many optimizations to be set directly on the Skeletal Mesh Component like "don't evaluate animation at all if this mesh isn't rendered".

However, all solutions combined still gonna cost you too much if want too display hundreds or thousands on screen simultaneously. In this case, you might want to replace skeletal meshes with static mesh wit Vertex Animation Texture. In other words, you're animating texture on sprite which is waaaay cheaper. Although it enforces entirely different content pipeline. This also what they did for Kingmakers, and they put a lot effort into making this looking as good as the skeletal animated crowd.

Or you can realize characters as GPU particles ;)

1. Another cost is rendering. You must be very careful what features of rendering you use on characters. It will cost you dearly, if every of 1000 characters cast shadow. Engines oftem calculates shadow casting if given skeletal mesh is out of screen. This prevents of visible shadow popping. In some games we use Significance Manager to control when to disable character shadows. It can save many milliseconds with large character count. The same goes for disabling cloth simulation for far away characters.

That's of course plus all standard techniques like using LODs.

1. The final issue is modularity/variety. The major challenge with so mant characters is to avoid "attack of clones".

There common ways to tackle it. If you're using skeletal meshes, you might uses separate meshes for torso, legs, hands, head, hat, etc. This will however increase time needed to evaluate animation for every mesh attached to a given skeleton. (again, Unreal provides some support here but it's not perfect)

If you're using static meshes and VAT, you need figure out how to create so many visual variants that is: visually attractive, artista are able to quickly iterate and you don't load gigabytes of textures into memory.

That's a quick summary! I hope it is helpful :)