Based on the interpretation of the FSF (the issuer of the GPL): No.
On the direct interpretation of your questions title it is pretty obvious. If I write an MS Office document in LibreOffice and read and change it in OpenOffice, it doesn't mean LibreOffice and OpenOffice create a combined work. Even more so if the format that is used for the exchange is originating from a third program: MS Office.
But you go more into detail in the question and specify the shared format is used for communication. And your other question points toward the interpretation you want this to know for the case the communication with the shared file format is forming an API.
But even for that case the answer is no. The simple usage of an API isn't creating a derivate and therefore triggering the GPL. The GPL is talking about linking the software, not about using an API. If linking is enough to create a derivate work is discussed, and not everyone shares the point of view of the FSF. But even the FSF stops at linking and I know of no one, who interprets the formation of a derivate even more inclusive than the FSF.
The FSF addresses this distinction in their FAQ:
If the modules are included in the same executable file, they are
definitely combined in one program. If modules are designed to run
linked together in a shared address space, that almost surely means
combining them into one program.
By contrast, pipes, sockets and command-line arguments are
communication mechanisms normally used between two separate programs.
So when they are used for communication, the modules normally are
separate programs. But if the semantics of the communication are
intimate enough, exchanging complex internal data structures, that too
could be a basis to consider the two parts as combined into a larger
As you can see, transferring files via Sockets or Pipes (including STDOUT and STDIN), does not qualify as combination into a larger program. The file could be also exchanged via a command-line parameter pointing to the position the file is saved. That is even more indirectly.
The FAQ has some consideration into 'complex internal data structures', so that could be an argument that both programs are combined. For a file with a defined content (needed for it being an API), we can argue against it being 'internal'. It's pretty obvious for text-files, that you defined in the question, internal data-structures (and that includes strings) have to be converted to fit into text-files. Strings have a length-integer at the beginning (seldom in use today) or are ended by a null-byte (more common). In a test-file strings are separated by a defined separator, commonly a line-break. That alone makes the data no longer internal.
But even for a binary file some sort of conversion is needed. Different compilers can lead to different memory-layout of data-structures: little vs. big-endian for multi-byte datatypes, direction for arrays, padding bytes included by the compiler, length of integers. If the file is part of an API all this has to be defined, meaning on a different platform with different compilers a conversion from the internal data-structure is needed.
However, always it might be the case that some jurisdictions use different interpretations, I rely on the interpretation of the FSF, as they issued the GPL the question was about.
FreeRadical points in a comment to the court case of FormGen vs. Micro Star about Duke Nukem level files. I have to explain it a bit, that is too long for comments:
This case is not the same situation as the question asks. The question of kdopen would be similar to Microstar creating a level editor (another program using the same file format). The case was about selling files created with the original level editor and about advertising the pack with screenshots. The screenshots indeed are derivates, as they contain information from both the level-file and copyrighted art from Duke Nukem. So the matter of the screenshots is pretty clear, however the court also concludes the map-files itself create a derivate. For that let interpret the map-file as a program. That is possible, as it contains instructions to the game engine how to use game art to create a new level. But still not matches kdopens question, as there are no two programs that are only linked together by a file format. In my question I cited the FSF with:
If modules are designed to run linked together in a shared address
space, that almost surely means combining them into one program.
This happens here, as the map-file is loaded by the game into the address-space of the game. But kdopens question was about linking through exchanged files, not that the file itself is the derivative.