Mfcttrf

Did bit one of the Intel 8080's Flags register, the bit between the carry and parity flags, get set to one on startup? If so what was the reason for this, and was this inherited from the 8008 Flags register?

Did bit one of the Intel 8080's Flags register, the bit between the carry and parity flags, get set to one on startup?

TL;DR:

No, as there is no flag register on the 8080. Only separate flags. The 'filler' bits (1, 3, 5) only get their value when PUSH PSW is executed.

Long Read:

The 8080 does not have a flag register, but like it's predecessor the 8008 separate flags. Which are, like other answers describe correct, at random state after power-up/reset.

The 8080 has no access in register form for the programmer. Only testing due conditioned instructions was possible. Setting could only be done via instructions with implied result stored in any of them. The only access as byte data was when pushed onto the stack.

When storing the flags to the stack (PUSH PSW) the second byte is synthesized from the flag bits and completed by 'filler' values for position 1, 3, 5 (1, 0, 0). This guarantees that in memory bit 1 always will be 1.

(From "8080 Assembly Language Programming Manual", "Rev B", p.22/23)

During store (PUSH PSW)

If register pair PSW is specified, the first byte of information
saved holds the contents of the A register; the
second byte holds the settings of the five condition bits,
i.e., Carry, Zero, Sign, Parity, and Auxiliary Carry. The format
of this byte is:

| | | |A| | | | |
|S|Z|0|C|0|P|1|C|

S State of Sign bit
Z State of Zero bit
0 always 0
AC State of auxiliary Carry bit
0 always 0
P State of Parity bit
1 always 1
C State of Carry bit

For retrieval (POP PSW):

[...] If register pair
PSW is specified, the byte of data indicated by the contents
of the stack pointer plus one is used to restore the values of
the five condition bits (Carry, Zero, Sign, Parity, and Auxiliary
Carry) using the format described in the last section.

If so what was the reason for this, and was this inherited from the 8008 Flags register?

In part, as they were separate single bit entities. Except the 8008 did not allow any access to the flags beside testing them in conditional instructions. There was no instruction to store or retrieve them at all.

Follow Up Tidbits:

The follow up 8085 did introduce a real flag register (*1), still not in the register file, but kept separate, like the A register as well (*2). Now bit 1 was used as V flag. That's one of the incompatibilities with 8080 code - and one way to detect a 8085, by pushing a cleared HL, poping PSW, pushing PSW again and then checking L. If bit 1 is still cleared, it's an 8085.

The Z80 in contrast made the flag register (or better both, as there's one for every register set) part of its huge register file, but now, at the begin of every instruction, copied the content of the flag register in use into seperate flag flip-flops, only to be copied back at the end. Beside simplifying the storage structure a must to support two register sets, including flags.

*1 - Well, almost, as only 7 storage bits are implemented. Bit 3 was replaced by a circuitry to always drive 0 when read.

*2 - On the 8008 the A register was a normal member of the register file.

According to the Intel 8080 microcomputer systems user’s manual, the contents of registers are indeterminate on startup:

The contents of its
program counter, stack pointer, and the other working regis-
ters are naturally subject to random factors and cannot be
specified.

and further on

Note, however, that
the RESET has no effect on status flags, or on any of the
processor's working registers (accumulator, registers, or
stack pointer). The contents of these registers remain inde-
terminate, until initialized explicitly by the program.

According to the manual, the only thing that is explicitly set after RESET in the 8080 is the program counter. Everything else is indeterminate:

Note, however,that the RESET has no effect on status flags, or on any of the processor's working registers (accumulator, registers, or stackpointer). The contents of these registers remain indeterminate, until initialized explicitly by the program.

If they don't initialize anything at all, it is very unlikely they'd initialize something that isn't even used.