While I use Annotated a good amount I mainly use it for adding metadata to classes to help derive parsers similar to pydantic. So for my usage of Annotated is I need it for any valid variable annotation at class level or __init__ annotation as I also allowed annotating __init__ instead of doing it dataclass style. P.args/P.kwargs is not a valid variable annotation, but it could be an annotation in an __init__. A class that wraps a function for some kind of task framework I guess. I could see usage of it to help serialize/deserialize functions with extra information. I haven't honestly looked closely at function serialization beyond simple name registration as I'm using this for config files and avoidant of having too much code live in the config. So maybe I would use this in a couple months or maybe I could continue to avoid. I also commonly attach docstring like metadata. This works with any reasonable annotation. You could use a library like docstring_parser, but well I've found it convenient and simple to attach documentation to arguments with Annotated. I think it would be reasonable usage though if I wanted alternative ways to serialize decorators. I could also see a potential use case for a library like beam/kubeflow. They are workflow orchestration libraries and they currently can use annotations to some level for describing sequence of computation tasks. If they want to support tasks generic over function signature they could use it. I'll admit honestly I'd be surprised if they did. For Annotated usage that fully ignores the type and only uses it for metadata instead of an extension, then Annotated[P.args, ...] makes sense. For libraries like pydantic/one I work on that use Annotated to extend information on top of type, it's rare to handle types like P.args or typevar T as you'll start to implement more and more type rules. Overall I think there are reasonable valid usages of Annotated[P.args, ...]. I don't expect them to be common, but generally lean towards Annotated only thing it should check is if first argument is valid as a type annotation. I rarely encounter P.args/P.kwargs in first place given there newness and mypy only recent support for them. I'll add Annotated[P.args] not working seems messier then Annotated[Final[...]] not working as I could hack around that with Final[Annotated[...]] and adjust my introspection code to check for Annotated inside any Final. Annotated[P.args] failing sounds like if I ever do need it I'd explore hacks like P.args | Annotated[Never, stuff] as I think P.args | Never is equivalent to P.args. Do all type checkers collapse Never/NoReturn unions to the other type?