Efficient way to move rows across the tables? This is somewhat long question as I would like to explain all details of the problem.

System Description

We have a queue of incoming messages from external system(s).
Messages are immediately stored in the e.g. INBOX table. Few thread workers
fetch the job chunk from the table (first mark some messages with UPDATE,
then SELECT marked messages). Workers do not process the messages,
they dispatch them to different internal components (called 'processors'),
depending on message command.

Each message contains several text fields (longest is like 200 varchars),
few ids and some timestamp(s) etc; 10-15 columns total.

Each internal component (i.e. processor) that process messages works differently.
Some process the message immediately, others triggers some long operation,
even communicating via HTTP with other parts of the system. In other
words, we can not just process message from the INBOX and then remove it.
We must work with that message for a while (async task).

Still, there are not too many processors in the system, up to 10.

Messages are all internal, i.e. it is not important for user to browse
them, paginate etc. User may require list of processed relevant messages,
but that's not mission-critical feature, so it does not have to be fast.
Some invalid message may be deleted sometimes.

Its important to emphasize that expected traffic might be quite high - and we don't
want bottlenecks because of bad database design. Database is MySql.

Decision

The one of the decisions is not to have one big table for all messages, with some flags column that will indicate various messages states. Idea is to have tables per
processors; and to move messages around. For example, received messages will be stored in INBOX, then moved by dispatcher to some e.g. PROCESSOR_1 table, and finally moved to ARCHIVE table. There should not be more then 2 such movements. W

While in processing state, we do allow to use flags for indicating processing-specific states, if any. In other words, PROCESSOR_X table may track the state of the messages; since the number of currently processing messages will be significantly smaller.

The reason for this is not to use one BIG table for everything.

Question

Since we are moving messages around, I wonder how expensive this is with high volumes. Which of the following scenarios is better:

(A) to have all separate similar tables, like explained, and move complete messages rows, e.g. read complete row from INBOX, write to PROCESSOR table (with some additional columns), delete from INBOX.

or

(B) to prevent physical movement of the content, how about to have one big MESSAGES table that just stores the content (and still not the state). We would still have other tables, as explained above, but they would contain just IDs to messages and additional columns. So now, when message is about to move, we physically move much less data - just IDs. The rest of the message remains in the MESSAGE table unmodified all the time.

In other words, is there a penalty in sql join between one smaller and one huge table?

Thank you for your patience, hope I was clear enough.
I think its faster (feel free to test) to keep the record in the same table while processing, but be sure to set an index on the column(s) that track which processor is using them.

Also use MyISAM tables if you don't require InnoDB's features. The ARCHIVE table can best be set to the archive type, so it does not make space for updates (if you don't need to write to it)