Haskell, 34 bytes

f n=iterate(scanl(+)1)[1..20-n]!!n

Try it online!

Uses zero-indexed inputs (f 4 returns tier 5.)

Haskell, 36 bytes

f 1=[1..20]

f n=init$scanl(+)1$f$n-1

Try it online!

Uses 1-indexed inputs (f 5 returns tier 5.)

Explanation

scanl (+) 1 is a function that takes partial sums of a list, starting from (and prepending) 1.

For example: scanl (+) 1 [20,300,4000] equals [1,21,321,4321].

It turns out that tier $n$ is just this function applied $ (n-1) $ times to the list $[1,2,3,dots]$.

(Or equivalently: $n$ times to a list of all ones.)

We use either init or [1..20-n] to account for the list getting longer by $1$ every application.

Wolfram Language (Mathematica), 34 bytes

0~Range~19~Binomial~i~Sum~{i,0,#}&

Try it online!

The tier $n$ metasequence is the sum of the first $n+1$ elements of each row of the Pascal triangle.

Jelly, 8 bytes

20ḶcþRS‘

Try it online!

   cþ       Table of binom(x,y) where:

20Ḷ           x = [0..19]

     R        y = [1..n]    e.g.  n=3 → [[0, 1, 2, 3, 4, 5,  …]

                                         [0, 0, 1, 3, 6, 10, …]

                                         [0, 0, 0, 1, 4, 10, …]]



      S     Columnwise sum.           →  [0, 1, 3, 7, 14, 25, …]

       ‘    Add one.                  →  [1, 2, 4, 8, 15, 26, …]

This uses @alephalpha’s insight that $$text{meta-sequence}_n(i) = sum_{k=0}^n binom ik = 1+sum_{k=1}^n binom ik.$$

Python 2, 69 58 55 bytes

Saved bytes thanks to ovs and Jo King; also, it works in Python 3 now as well.

m=lambda t:[1+sum(m(t-1)[:n])for n in range(~t and 20)]

Try it online!

The math

Let $a(t,n)$ be the $n^{th}$ term (0-indexed) of the sequence at tier $t$. A little analysis leads to the following recurrence formula:

$$
a(t,n) = 1+sum_{i=0}^{n-1}a(t-1,i)
$$

Working backwards, we define $a(0,n) = 1$ and $a(-1,n) = 0$ for all $n$. These definitions will simplify our base case.

The code

We define a function m(t) that returns the first 20 elements of the sequence at tier t. If t is nonnegative, we use the recursive formula above; if t is -1, we return an empty list. The empty list works as a base case because the result of each recursive call is sliced ([:n]) and then summed. Slicing an empty list gives an empty list, and summing an empty list gives 0. That's exactly the result we want, since tier $-1$ should behave like a constant sequence of all $0$'s.

m=lambda t:                     # Define a function m(t):

 [          ]                   # List comprehension

     for n in range(         )  # for each n from 0 up to but not including...

                    ~n and 20   # 0 if n is -1, else 20:

  1+sum(          )             # a(t,n) = 1 + sum of

              [:n]              # the first n elements of

        m(t-1)                  # the previous tier (calculated recursively)

Pari/GP, 39 bytes

n->Vec(sum(i=1,n+1,(1/x-1)^-i)+O(x^21))

Try it online!

Pari/GP, 40 bytes

n->Vec((1-(1/x-1)^-n++)/(1-2*x)+O(x^20))

Try it online!

The generating function of the tier $n$ metasequence is:

$$sum_{i=0}^nfrac{x^i}{(1-x)^{i+1}}=frac{1-left(frac{x}{1-x}right)^{1+n}}{1-2x}$$

dzaima/APL REPL, 14 bytes

(+1,19↑)⍣⎕⍳20

Try it online!

(+1,19↑)⍣⎕⍳20

(       )⍣⎕     repeat the function below input times:

 +               cumulative sum of

   1,             1 prepended to

     19↑          the first 19 items of the previous iteration

           ⍳20  starting with the first 20 integers

Perl 6, 34 32 bytes

-2 bytes thanks to Jo King

{(@,{[+] 1,|.[^19]}...*)[$_+1]}

Try it online!

Explanation

{                              }  # Anonymous block

   ,                ...*  # Construct infinite sequence of sequences

  @  # Start with empty array

    {              }  # Compute next element as

     [+]     # cumulative sum of

          1,  # one followed by

            |.[^19]  # first 19 elements of previous sequence

 (                      )[$_+1]  # Take (n+1)th element

Python 3.8 (pre-release), 62 bytes

f=lambda n:[t:=1]+[t:=t+n for n in(n and f(n-1)[:-1]or[0]*19)]

Try it online!

Explanation

f=lambda n:     # funtion takes a single argument

     [t:=1]     # This evaluates to [1] and assigns 1 to t

                # assignment expressions are a new feature of Python 3.8

       +        # concatenated to

     [  ....  ] # list comprehension



# The list comprehesion works together with the

# assignment expression as a scan function:

[t := t+n for n in it]

# This calculates all partial sums of it 

# (plus the initial value of t, which is 1 here)



# The list comprehension iterates

# over the first 19 entries of f(n-1)

# or over a list of zeros for n=0

 for n in (n and f(n-1)[:-1] or [0]*19)

JavaScript (ES6),  68  67 bytes

f=(n,a=[...f+f])=>n--?f(n,[s=1,...a.map(x=>s-=~--x)]):a.slice(0,20)

Try it online!

JavaScript (ES6), 63 bytes

NB: this version works for $nle20$.

f=(n,a=[...Array(20-n)])=>n--?f(n,[s=1,...a.map(x=>s+=x||1)]):a

Try it online!

J, 24 bytes

<:(1+/@,])^:[(1+i.20)"_

Try it online!

NOTE: Turns out this is a translation of dzaima's APL answer, though I actually didn't notice it before writing this.

explanation

<: (1 +/@, ])^:[ (1+i.20)"_

<:                           NB. input minus 1 (left input)

                  (1+i.20)"_ NB. 1..20 (right input)

   (         )^:[            NB. apply verb in parens 

                             NB. "left input" times

   (1     , ])               NB. prepend 1 to right input

   (  +/@   )               NB. and take scan sum

Wolfram Language (Mathematica), 42 bytes

Nest[FoldList[Plus,1,#]&,Range[21-#],#-1]&

Try it online!

Ruby, 49 bytes

f=->n{n<1?[1]*20:[o=1]+f[n-1][0,19].map{|x|o+=x}}

Recursive definition: Tier 0 is 1,1,1,1... and each subsequent tier is 1 followed by a sequence whose first differences are the previous tier. Annoyingly this would give me 21 values if I didn't explicitly slice out the first 20; seems like there should be a way to shorten this by avoiding that.

JavaScript (Node.js), 58 bytes

t=>Array(20).fill(t).map(g=(t,i)=>i--*t?g(t,i)+g(t-1,i):1)

Try it online!

It is trivial to write down following recursive formula based on the description in question
$$ g(t,i)=begin{cases}
g(t,i-1)+g(t-1,i-1) & text{if} quad icdot t>0 \
1 & text{if} quad icdot t=0 \
end{cases} $$
And you just need to generate an Array of 20 elements with $[g(t,0)dots g(t,19)]$

05AB1E, 11 9 bytes

20LIF.¥>¨

0-indexed

Try it online or verify all test cases.

Explanation:

20L        # Create a list in the range [1,20]

   IF      # Loop the input amount of times:

     .¥    #  Get the cumulative sum of the current list with 0 prepended automatically

       >   #  Increase each value in this list by 1

        ¨  #  Remove the trailing 21th item from the list

           # (after the loop, output the result-list implicitly)

Ruby, 74 bytes

a=->b{c=[1];d=0;b==1?c=(1..20).to_a: 19.times{c<<c[d]+(a[b-1])[d];d+=1};c}

Ungolfed version:

def seq num

    ary = [1]

    index = 0

    if num == 1

        ary = (1..20).to_a

    else

        19.times{ary << ary[index]+seq(num-1)[index]; index+=1}

    end

    return ary

end

Quite resource-intensive--the online version can't calculate the 13th metasequence.

Try it online

Jelly, 10 bytes

20RṖ1;ÄƲ⁸¡

Try it online!

0-indexed.

R, 59 bytes

Reduce(function(x,y)diffinv(x,,,y),!!1:scan(),!!1:19)[1:20]

Try it online!

Repeated diffinv with xi=1, and subset out the first 20 terms.

Retina, 59 bytes

.+

19*$(_,

Replace the input with 19 1s (in unary). (The 20th value is 0 because it always gets deleted by the first pass through the loop.)

"$+"{`

)`

Repeat the loop the original input number of times.

(.+),_*

_,$1

Remove the last element and prefix a 1.

_+(?<=((_)|,)+)

$#2*

Calculate the cumulative sum.

_+

$.&

Convert to decimal.

Try it online!

C# (Visual C# Interactive Compiler), 120 bytes

n=>{for(long i=-1,h=0,m=0;++i<20;Print(i<1?1:h))for(m=h=0;m<=n;)h+=f(i)/(f(m)*f(i-m++));long f(long a)=>a>1?a*f(a-1):1;}

Try it online!

Based off of alephalpha's formula.

K (oK), 18 bytes

{x(+1,19#)/1+!20}

Try it online!

0-indexed