Representation languages such as frames often have their semantics defined in terms of predicate (or other) logics. Once we have defined precisely what all the expressions and relations mean in terms of a well understood logic then we can make sure than any inferences that are drawn are sound, according to that logic. For example, we could decide that if an object elephant has a definite slot colour with value grey then this means that:
X elephant(X)
colour(X,Y)
grey(Y).
(and similarly for any other definite slot)
If we have slots that take default values then we will need a more powerful logic to represent their meaning, such as a default logic.
Using a representation language with a logic-based semantics has the advantage that we can deal (on the surface) with a simple, natural representation language such as frames, while underneath we can be quietly confident that the inferences drawn by the system are all sound. Of course, we have to understand the semantics of the language to be able to represent things meaningfully in it, but this may not be as awkward as dealing directly with the logic.
Another possible ``advantage'' of this approach is that something like a frame system typically has restricted representational power compared with full predicate (or default) logic. This may sound like a disadvantage, as it will mean there are some things we can't represent. However, the gain in efficiency you get by reasoning with a restricted subset usually makes this tradeoff worthwhile. In fact, new logics (called terminological logics) have been developed, which have the expressive power needed to perform inheritence type inferences on simple properties of classes of objects (as in frame systems), but which do not allow some of things (deductions etc) possible in predicate logic. These allow you to reason directly in the logic, rather than using the special inferences of a frame system, which are only indirectly validated by a logical semantics. Terminological logics have more restricted expressive power than predicate logic, but greater efficiency.
So, you can choose between a logic with (fairly) great expressive power, but rather inefficient (and undecidable) inference and proof procedures, or a logic with slightly weaker representational power, but which you can reason with efficiently. Or you can use something like a frame system, which may (or may not) have a well defined semantics, and which uses special purpose inference procedures to perform class related deductions (such as inheritance of slot values from parent classes).