While Litman's meta-planning schemas are used to follow the structure of a domain-level plan, Ramshaw  uses meta-planning to also choose the domain plan. In a situation where there is an agent with limited knowledge of the domain state, and an expert user who has wide domain knowledge, the agent may need to explore several domain plans, consulting the expert about each one, and if a plan should thereby fail, it may need to backtrack and try an alternative way of constructing the plan. Ramshaw defines a "build-plan" action, which can be achieved by several different "build-subplan" actions, with backtracking over these alternatives. Ramshaw's planner backtracks because of failed preconditions. Some preconditions can be satisfied using y/n and wh- queries, named "check-pred-value" and "ask-pred-value". Some preconditions can be satisfied in many ways, for example, there may be ten different ships suitable for the agent's battle plan, each of which may be used to instantiate a parameter to a plan schema. The "ask-fillers" action is one of a family of actions used for this sort of query. Ramshaw suggests that a future direction for his planner is rather than seeking out the first workable plan, to use a quantitative comparison of competing plans in a negotiation dialogue. This suggestion is taken up in this thesis.
Smith and Hipp  describe a planner that is quite similar to Ramshaw's backtracking meta-planner, in that it too uses a backtracking search, controlled by a Prolog interpreter, to find a solution for a domain-level plan. Where Ramshaw's planner always uses system initiative, only allowing the expert to respond to queries, their planner allows differing levels of initiative whereby both agents can answer queries, ask queries, give unasked-for information, and introduce goals to different extents. This requires a richer model of the user than one of the passive knowledge-base used by Ramshaw. They use a model that encompasses problem solving capabilities as well as domain-state knowledge. Problem-solving knowledge is encoded as Prolog rules, with some subgoals being achieved by rules that are within the user model. The system passes control to the user whenever these subgoals are invoked. They even give an example of a clarification where the user is given control for a subgoal, and then for a further subgoal the user passes control back to the system, thereby using a deeply nested user model.