List<T> is not a covariant type.

If it were, one problem is that classes may operate differently depending upon their assigned generic type. For example, imagine this:

class Foo<T>
{
    public bool FooBar()
    {
        return typeof(T).Name.ToLower() == "object";
    }
}

Now, if you allowed Foo<string> to be cast to Foo<object>, what does FooBar() return after the cast?

There are three solutions:

1. Just use List<object> and add Tuple<string, bool> type instances to it.
2. Cast to IList. This has potential downsides, though, as you're expecting a List<T> and a different class that implements IList might be passed.
3. Turn your accepted list types into a hierarchy and use a list of the base type, for example:

.

abstract class Animal { }

class Cat : Animal { }
class Dog : Animal { }

public List<Animal> animals = new List<Animal>();

Then you can call .Add() and other methods with Cat or Dog objects as parameters, check the types of each entry with is, and avoid the cast entirely. Whether this is appropriate depends on your types and how they interact, though.

List<T> isn't covariant. You can't do that. If you want, create a List<object> and fill that with all elements. Although I don't really see the advantage of using a strongly typed generic list with object.