It looks like Elasticsearch is currently missing support for concurrent searching and that this is a major prospective optimization to reduce latency.

Digression: this is not the topic at hand but I personally consider the fork OpenSearch to be an historical tragedy of duplication of work and a segregation of improvements. What would be even more anti-utilitarist would be to blindly *ignore* each other advances towards making better search.

Lucene concurrent search APIs are probably among the most important feature/optimization currently not leveraged by Elasticsearch.
The fork OpenSearch has a [pull request](https://github.com/opensearch-project/OpenSearch/pull/1500) implementing support for it.

See also the [corresponding issue](https://github.com/opensearch-project/OpenSearch/issues/1286) 

I believe it would be great for end users if you could take inspiration from the PR and work on this feature.

Great blog about the Lucene feature:
https://blog.mikemccandless.com/2019/10/concurrent-query-execution-in-apache.html?m=1
See also those performance results:
https://engineeringblog.yelp.com/2021/09/nrtsearch-yelps-fast-scalable-and-cost-effective-search-engine.html
test/framework/src/main/java/org/elasticsearch/test/ESIntegTestCase.java
* @param forceRefresh   if {@code true} all involved indices are refreshed once the documents are indexed.
     * @param dummyDocuments if {@code true} some empty dummy documents may be randomly inserted into the document list and deleted once
     *                       all documents are indexed. This is useful to produce deleted documents on the server side.
     * @param maybeFlush     if {@code true} this method may randomly execute full flushes after index operations.
     * @param builders       the documents to index.
     */
    public void indexRandom(boolean forceRefresh, boolean dummyDocuments, boolean maybeFlush, List<IndexRequestBuilder> builders)
        throws InterruptedException {
        Random random = random();
        Set<String> indices = new HashSet<>();
        builders = new ArrayList<>(builders);
        for (IndexRequestBuilder builder : builders) {
            indices.add(builder.request().index());
        }
        Set<List<String>> bogusIds = new HashSet<>(); 
        if (random.nextBoolean() && builders.isEmpty() == false && dummyDocuments) {
            builders = new ArrayList<>(builders);
            
            final int numBogusDocs = scaledRandomIntBetween(1, builders.size() * 2);
            final int unicodeLen = between(1, 10);
            for (int i = 0; i < numBogusDocs; i++) {
                String id = "bogus_doc_" + randomRealisticUnicodeOfLength(unicodeLen) + dummmyDocIdGenerator.incrementAndGet();
                String index = RandomPicks.randomFrom(random, indices);
                bogusIds.add(Arrays.asList(index, id));
                
                builders.add(client().prepareIndex().setIndex(index).setId(id).setSource("{}", XContentType.JSON).setRouting(id));
            }
        }
        Collections.shuffle(builders, random());
        final CopyOnWriteArrayList<Tuple<IndexRequestBuilder, Exception>> errors = new CopyOnWriteArrayList<>();