Currently the proposal for std::out_ptr outlined in P1132R8 (https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1132r8.html#wording-library) gives std::out_ptr only implicit conversion operators to its pointer type or void**:

template <class Smart, class Pointer, class... Args>
	class out_ptr_t {
	public:
		// 20.11.9.1, constructors
		explicit out_ptr_t(Smart&, Args...);
		out_ptr_t(const out_ptr_t&) = delete;

		// 20.11.9.2, destructors
		~out_ptr_t();

		// 20.11.9.3, conversion operators
		operator Pointer*() const noexcept;
		operator void**() const noexcept;

	private:
		Smart& s; // exposition only
		tuple<Args...> a; // exposition only
		Pointer p; // exposition only
	};

I could see plenty of utility in adding an additional operator Pointer*& that would support legacy C++ api's (e.g., factory methods) that assigned to output pointers by lvalue reference.

Here's a contrived example (godbolt link: https://godbolt.org/z/G9GofMbxd)

#include <iostream>
#include <memory>

struct FakeOutPtr
{
FakeOutPtr(std::unique_ptr<int>& ptr)
: m_smart_ptr(std::addressof(ptr))
{}
~FakeOutPtr()
{
m_smart_ptr->reset(storage);
}
std::unique_ptr<int>* m_smart_ptr;
int* storage = nullptr;
operator int*(){return storage;}
operator void**(){return static_cast<void**>(static_cast<void*>(storage));}
operator int*&(){return storage;}
};

void assign(int*& ptr)
{
ptr = new int(42);
}

int main()
{
std::unique_ptr<int> my_ptr;
assign(FakeOutPtr(my_ptr));
std::cout << *my_ptr;
}

The above could would not compile with the current proposal. I think the addition of an implicit conversion to Pointer*& provides a lot of utility in exchange for not a lot more complexity to the proposal.