I have spent much of this year with a swarm of AI agents researching China as a great power. This post is not about China, business or cyber. It is about what happened to my workflow along the way: a gradual evolution I expected to happen, and then a revolution I did not.
I have worked the national security mission for more than twenty years, first building capabilities that people wiser than I was had defined, then designing the ones we would build, deploy, operate and support. As I became a lot less young and a little more wise, that meant I spent a good part of my day in non-English documents, systems, and data.
I do not have the talent for foreign languages. That’s an understatement. I have to study to be able to use a single curse word in a foreign language. So long ago I evolved a workflow that accommodated my weakness at languages. That foreign-language information went through static translation tools first, some commercial, some government-built, and all awful at the technical terminology I actually needed to understand. Then I worked the rest of the project in my native English. Translate first, then work.
In 20/20 hindsight the workflow was horrendous. It’s not just that the tools were bad. They were. It is that the whole workflow was held back by my weakness. On the rare occasion that I brought in a human translator they themselves didn’t understand the technical idioms to translate them. That part of my workflow is where information was lost. I never took a hard look at the step that worked. It kept working, so it stayed.
The kinda-upgrade
That translation stage before I performed real work became that baby picture on your fridge that you never look at, that you can’t even figure out which kid it is. I was always looking for a better translator, and then machine translation got really really good.
A better tool replacing an old tool doesn’t change things much. You might get more productivity, cheaper results, more safety, better precision. But you’re getting the same thing in the end. Large language models (LLMs) are really, really good at translation. They handle even highly idiomatic material, and they turn it into English I can actually use. I put them in as the translator in my workflow long ago. I have had my GPUs burning tokens for months translating piles of data into English and making my home office too warm for comfort.
But nothing really changed. Sure, I could do more projects, and do them more quickly. My projects were still in English. I searched for data in English even when the source data was in other languages. All of the incremental results were in English because English is what I think in. A workflow is a set of assumptions with tools plugged into them, and the assumption underneath mine was that the world had to become English before I could make sense of it.
I have been re-evaluating so many of my assumptions about China this summer that identifying those assumptions must be becoming habit. I finally took that ancient baby picture off the fridge, turned it around, and realized it wasn’t even a picture of my kid. In this case, the project was a pile of 70m court records. The plan was the same old plan: translate all of it, then do the research. I left the translation job running on my GPUs and walked away with a tool tracking the progress so I knew when I could start sifting through the data for what I suspected was in there. The first reading said six years. The last reading that day said twenty-five years. That’s not a graph you want to see go up and to the right.
Each dot is one reading of the running translation service on a single day. The red trace is that service’s own estimate to complete the whole pile of data, and the flat gray trace underneath is the share it had actually finished translating.
My workflow was blocked by translation. I have been far more productive this year by using LLMs to translate my smaller data holdings. I replaced the tool with a better tool. Then the thing that changed my workflow is easier to explain with something that happened to me as a programmer.
When code was code
Fluency in a particular programming language is something that you lose the need for. When I was a younger software engineer I wrote everything in C and assembler. That was the work. Then the work shifted. New projects came with new languages, new targets came with new hardware architectures, and each architecture meant learning to read and write its assembler from scratch. I learned tons of them. Sparc assembler still holds a special place in my heart. Each programming language had its own grammar, and each processor architecture had its own machine quirks in the assembler.
Then at some point, code just became code. A new language was no longer a new thing to learn. It was just a new dialect of what I already knew. After a few minutes with its nuances and its grammar I could read it, write it, and cuss out Larry Wall if it reminded me of Perl. The syntax was the surface. Underneath it, every language was expressing the same small set of ideas about data and control, and once I could see the ideas the surface stopped mattering. A computer worked like a computer regardless of programming language.
I did not notice the workflow boundary when I crossed it. I doubt anyone does. There is no day when you are a C programmer in the morning and a programmer in the afternoon. You find out later, when someone hands you something in a language you have never seen, you read it anyway, see the vulnerability, and can write the fix. Code was code regardless of language. What you have stopped needing is the translation. You no longer take the new language back to the one you learned first in order to understand it. You understand it as it is.
The large language model crossed the same boundary. So had I, long before, in a programming language domain. And I still failed to truly internalize that the machine did it.
When language is language
Something funny happened recently on the way to a past Substack article. I stopped working in English. The recognition arrived the way the programming one did. Late and not with a bang but with a whimper.
The LLM works on language. It is a large language model. If it was largely trained, then language is language to it. The same way code became code to me. It does not take a document back to English in order to understand it, any more than I would take a programming language back to my native C language. It understands the data where it is. And a vision model does the same thing with pictures: it encodes an image into tokens, which is the same framework the model was going to reason over anyway. Inside the AI there are only tokens of language, not individual languages.
The translation that finished in the graph below shows you why the one that did not was never going to. I translated the metadata: the court names, the causes of legal action, the place names, and the document titles. They all finished in 83 minutes because most of those were repeated many times across the database. The pile of document bodies was never going to translate in my budget, or my attention span.
The two dots are counts on a logarithmic scale, which is the only scale that lets both sit on one axis, and the bars beneath are how much of each was translated.
I and the research projects needed those initial translations. Like it or not, the frontier AIs today are really good at answering questions. They are less good at noticing the “oh, that looks funny” and asking the right questions. At least for me, that is still my role. And I sadly have to execute my role in English.
But my old workflow did not distinguish between the two. It blocked all work until everything was translated. And everything takes years. Which means my work could never start. But that’s not the real problem with translating everything to English.
Translating everything before analysis is also lossy in a way that I haven’t been able to quantify yet. The translation between language loses some of the information in the translation. I noticed the loss. Local LLMs reasoning over the native language elevated multiple “oh, that’s funny” instances to me. The AI didn’t know what it really meant or how to ask the followup questions. But reasoning in the native language had eureka moments that did not happen with the English translations.
The last mile
So I stopped translating data. I work over all languages now. Well, my swarm of agents doing the heavy lifting works over all languages now. The hard proof that the translate-first step is not required came out of the same pile of Chinese-language data. I shut down the translation on the last day of August. The following week a later project needed those court records for something else I’m working on. That project queried the identical index, with the same 70m document bodies, still in Chinese. It never reached for the metadata that I still had translated into English in the same database. It went straight to the Chinese metadata, then to the Chinese freeform bodies of text. Of that project’s 94 discovery-grade findings, 5 went through the Chinese court records without ever being translated to English. The project pivoted from another data source, through the court records, nothing but Chinese.
The machine does not care what language anything is in, and that would be the end of the story if the machine were doing everything. It’s my workflow, and I still only read English.
The problem with an all-language workflow is the English speaker at the end of it. It is more than a little annoying that my interactions with my own agents are multilingual when I am not. My first instinct was the old mistake in a new place: tell the agents to talk to me in English. Told to do that, an agent ends up with a lot more English in its context window, and its results drift toward an English bias. The constraint on the output leaked back into the reasoning over the inputs.
The better results come when the agent swarm and the orchestrators above it are unconstrained and multilingual. The swarm talks to the orchestrators, the orchestrators talk to me, and nobody in that chain is told what language to think in. The English speaker is a fact about the interface, so the fix went there: one more agent between my orchestrator and me, whose only job is to translate into English so that I can read it. Translation used to be the first step, applied to everything the machine would see. Now it is the last, applied only to what I need to see.
The honest cost is that I no longer understand all of my own intermediate results. The swarm and the orchestrators reason in languages I cannot read, and the English I see comes out of a chain that loses some of the Chinese context. I cannot argue with a term any more. That is a genuine trade, and I made it because the English I used to read was never the source either. It was a static translation that mangled the terminology I cared about, so I was trusting a machine then too. The error still enters. It enters once, at the last mile, on the way to me, and it cannot reach back into what the swarm saw. The error belongs at the end of the pipe. And I find that I am asking a lot more questions to help me think and reason about the subtleties coming out of the system.
Every workflow has steps that exist because of a limit the person who built it had on the day they built it. The tools stop sharing that limit long before the workflow does, because the step keeps working, and nobody audits a step that works like it did yesterday and the day before. The way to find those steps is to ask of each whether it is there for the actual workflow, or there for you. The ones that are there for you belong at the end of the pipe where the cost doesn’t compound as the information moves through.
That has been the revolution in my workflow. Letting the language models work in all languages instead of limiting them to my weakness of only speaking English.