Why Finite Automata are restricted in reading the input?
Yes, there are things you could do to finite automata to make them more powerful. However, "with great power(er) comes great(er) responsibility."

Finite automata aren't very powerful but the languages they express&nbsp;&ndash; the regular languages&nbsp;&ndash; form a natural and important class.  Furthermore, for a fixed automaton, you can decide in linear time (with respect to the input) and constant working space whether it accepts or rejects any particular string. This is true even if the automaton is nondeterministic.

OK, but lots of important languages can't be decided by finite automata.  Important examples include anything that involves bracket matching, including the syntax of any sane programming language. How might you try to make automata more powerful and what would the cost be?


Suppose we allow the machine to scan both left and right along its input. This gives a two-way automaton.  Well, it turns out that two-way automata (deterministic or nondeterministic) still only accept regular languages&nbsp;&ndash; the same as ordinary automata. The two-way automaton might require fewer states and you can still determine whether it accepts a given input in linear time.  But now there's the possibility that the automaton can loop forever, so you need to check for that, which requires a logarithmic amount of working space, instead of constant.  (Since the number of steps before termination is bounded by some linear function of the length of the input, you can detect looping by counting steps and halting if the computation runs too long.  The counter needs a logarithmic number of bits.)
Suppose you allow the automaton to move backwards and forwards as well as overwrite its input, but not to use any more space than the input takes up.  This does make the machine more powerful (for example, you can now detect well-matched bracketings by "crossing out" the brackets one by one) but it makes it even harder to determine whether the machine accepts its input and to check for infinite loops.  Now, halting might take exponentially many steps, so you need a polynomial-length counter (linear is probably enough).
Suppose you allow the automaton to move backwards and forward, overwrite its input and use as much additional space as it wants.  Now your automaton has become a Turing machine.  It can do (we think) anything that any reasonable computer can do but there's no way of determining whether it accepts its input except for running the machine and hoping it eventually stops. This could take arbitrarily long and use arbitrarily much working space.


There are plenty of other possible additions to automata (for example, stacks) but they don't fit as neatly into the discussion above.

So, yes, you might want to make automata more powerful.  But doing so brings risk and expense that you might not be prepared to tolerate, if you don't need it.