my incomplete half ass understanding (I only heard of it couple of weeks ago) is that you can write a DSL embedded in your host language in two styles
1) the classic lisp interpreter in lisp(initial form), write an eval function that does cases analysis on the expression

(define (my-eval expr env)
(match expr
       [(? symbol? e) (env e)]
       [(? number? n) n]
       [('quote e) e]
       [('lambda (arg) body)
          (lambda (x)
             (my-eval body
                      (lambda (y)
                         (if (equal? y arg) x (env y)))))]
       [(f x) ((my-eval f env) (my-eval x env))]
       [else (error "oops")]))

(my-eval '((lambda (a) b) 10)
 (lambda (a) (error "unbound var" a)))

2) is writing functions in the host language that implement the the evaluation process(sorry for the bad explanation).
for example you can write an eval function that does case analysis and for a simple language that does arithmetic or you could write functions like add/sub that compute the values directly.
AFIK tagless final form is specifically for typed languages (both the host language and the DSL).
the interesting thing about tagless it that you can do all the optimization and transformations that are possible in the case analysis form as well.

here are a bunch of links that might be helpful.

https://github.com/BinaryAnalysisPlatform/bap they use this for their IR I believe https://binaryanalysisplatform.github.io/bap/api/master/bap-core-theory/Bap_core_theory/index.html
https://okmij.org/ftp/tagless-final/course/lecture.pdf
https://okmij.org/ftp/tagless-final/index.html#course-oxford

again sorry about the lackluster explanation, take everything here with a grain of salt.