Inference over external SPARQL endpoint (not supporting inference)

Writing a generic reasoner on top of an external plain-ol' SPARQL engine is possible for something like RDFS using multiple queries, but won't be very efficient in many cases. You could query for all of the RDFS schema information and then cache that, using it on the client side for a technique called "query-rewriting". (This might be an interesting research problem.)

However, the more practical option in many scenarios is to try capture the inference directly in the query. For example, to find all instances of foaf:Agent (inferred or otherwise), you could try the following in SPARQL 1.1 using property-paths:

   SELECT ?s
   WHERE {
      ?s a ?class . ?class rdfs:subClassOf* foaf:Agent .
   }

(Edited to use zero-to-many match instead of union based on Andy's comment. Thanks!)

Of course, with this approach, you would not find instances inferred to be foaf:Agent through the other rules like rdfs:domain or rdfs:range. You could extend the query further to find such inferences, but could not support all of RDFS in a single query like this (due to potential cycles in rule dependencies and the lack of true recursion in SPARQL).

Building on @Signified's answer: you can cache locally for any given query (with any set of rules). Take each of the triple, or quad patterns in the query, break them out of the query and run them separately, then cache them in your triple store. Then run your inferences and add them to the cache. Then run your original query on your cache. This doesn't always work if any of the individual triple/quad patterns return results that are too large to transmit or store.

Building on @harschware's answer, you don't have to limit yourself to your remote store's intended semantics. If you use a CONSTRUCT query to extract out your triples, you can merge that with any old ontology you come up with, using a reasoner on the whole.