05AB1E, 5 bytes

l#€нË

Try it online!

l      # Lowercase input.

 #     # Split on spaces.

  €н   # a[0] of each.

    Ë  # All equal?

Did this on mobile excuse the no explanation.

Python 2, 47 bytes

lambda s:len(set(zip(*s.lower().split())[0]))<2

Try it online!

Came up with this on mobile. Can probably be golfed more.

Clojure, 80 bytes

Try it online!. TIO doesn't support Clojure's standard String library though, so the first version will throw a "Can't find lower-case" error.

(fn[s](use '[clojure.string])(apply =(map first(map lower-case(split s #" ")))))

Ungolfed:

(defn tautogram? [s]

  (use '[clojure.string])

  (->> (split s #" ") ; Get words

       (map lower-case)

       (map first) ; Get first letter of each word

       (apply =))) ; And make sure they're all the same

I made a version that avoids the import:

(fn [s](apply =(map #(if(<(-(int %)32)65)(int %)(-(int %) 32))(map first(take-nth 2(partition-by #(= % )s))))))



 ; -----



(defn tautogram? [s]

  (->> s

       (partition-by #(= %  )) ; Split into words

       (take-nth 2) ; Remove spaces

       (map first) ; Get first letter

       ; Convert to uppercased letter code

       (map #(if (< (- (int %) 32) 65) ; If attempting to uppercase puts the letter out of range,

               (int %) ; Go with the current code

               (- (int %) 32))) ; Else go with the uppercased  code

       (apply =))) ; And check if they're all equal

But it's 112 Bytes.

PowerShell, 57 50 41 bytes

(-split$args|% s*g 0 1|sort -u).count-eq1

Try it online!

Takes input and splits it on whitespace. Loops through each word, and grabs the first letter by taking the substring starting at position 0 and going for 1 character. Then sorts the letters (case-insensitive by default) with the -unique flag to pull out only one copy of each letter, and verifies the count of those names are -equal to 1. Output is implicit.

-9 bytes thanks to mazzy.

05AB1E (legacy), 5 bytes

#€¬uË

Try it online!

#     // split on spaces

 €¬   // get the first letter of each word

   uË // check if they're the same (uppercase) letter

Brachylog, 5 bytes

ḷṇ₁hᵛ

Try it online!

         The input

ḷ        lowercased

 ṇ₁      and split on spaces

   hᵛ    is a list of elements which all start with the same thing.

Haskell, 71 bytes

f s|c<-fromEnum.head<$>words s=all(`elem`[-32,0,32]).zipWith(-)c$tail c

Try it online!

Haskell, 61 58 bytes (using Data.Char.toLower)

• Saved three bytes thanks to nimi.

import Data.Char

(all=<<(==).head).(toLower.head<$>).words

Try it online!

Perl 5 (-p), 20 bytes

$_=!/^(.).* (?!1)/i

TIO

following comments in case bad punctuation (31 bytes)

$_=!/^W*+(.).*(?=bw)(?!1)/i

31 bytes

otherwise there's another approach, also with 31 bytes:

$h{ord()%32}++for/w+/g;$_=2>%h

31 bytes other

JavaScript (Node.js), 54 bytes

s=>!s.match(/bw+/g).some(p=s=>p-(p=Buffer(s)[0]&31))

Try it online!

Or 47 bytes if each word (but the first) is guaranteed to be preceded by a space.

Japt -¡, 5 bytes

¸mÎro

Try it

¸mÎro     :Implicit input of string

¸         :Split on spaces

 m        :Map

  Î       :  Get first character

   r      :Reduce by

    o     :  Keeping the characters that appear in both, case-insensitive

          :Implicit output as boolean

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

n=>n.Split().GroupBy(c=>c[0]|32).Single()

Throws an exception if false, nothing if true.

Try it online!

Perl 6, 19 bytes

{[eq] m:g/<<./}o&lc

Try it online!

Java, (36 bytes)

s->!s.matches("(?i)(.).* (?!\1).*")

TIO