05AB1E, 5 bytes

l#€нË

Try it online!

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.

PowerShell, 57 50 bytes

(-split"$args"|%"$($_[0])"|group).Name.count-eq1

Try it online!

Takes input and splits it on whitespace. Loops through each word, takes the first letter $_[0]. Then groups the letters (case-insensitive by default), takes the names, and verifies the count of those names are -equal to 1. Output is implicit.

The Group).Name.count seems long, but I can't figure out how to shorten it yet.

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.

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

Perl 5 (-p), 20 bytes

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

TIO

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!

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

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.