이미 블랙박스가 아닌 것부터 걷어내자

우리는 이미 transformer가 attention과 MLP를 통해 계산한다는 architecture를 안다. 더 나아가 최근 mechanistic interpretability는 prompt 하나에 대해서 어떤 latent feature들이 활성화되고 서로 어떤 causal interaction을 거쳐 출력에 영향을 주는지를 attribution graph 형태로 어느 정도 추적할 수 있다. Claude 3.5 Haiku에서는 시를 쓰기 전에 뒤의 rhyme 후보를 미리 활성화하는 planning, 언어가 달라도 공유되는 추상 회로, 서로 다른 상황에서 재사용되는 addition 회로, 내부적으로 후보 진단을 만들고 추가 질문을 선택하는 과정까지 관측됐다. (Transformer Circuits)

심지어 2026년 7월의 Anthropic 연구는 더 이상 “모델 전체에 뭐가 들어 있나?”만 보는 게 아니라 작고 privileged한 내부 representational subspace가 여러 downstream computation에서 공용 argument처럼 사용되는 것을 보고했다. 그들은 이 J-space가 보고 가능하고, instruction으로 어느 정도 조작 가능하며, multi-step reasoning의 intermediate 값을 담고, 한 context에서 떼어낸 representation을 다른 context의 operation이 그대로 사용할 수 있는 성질까지 보인다고 보고한다. (Transformer Circuits)

그리고 일부 모델은 activation에 인위적으로 넣은 concept을 어느 정도 감지하고, raw text input과 내부 representation을 구분하며, 지시에 따라 특정 내부 concept representation을 올리거나 억제하는 제한적인 introspection까지 보인다. 다만 이 능력은 아직 매우 불안정하고 context-dependent하다. (Transformer Circuits)

Tool use에서도 내부는 완전히 침묵하지 않는다. 2026년 연구에서는 tool을 호출하기 전의 activation에서 tool이 필요한지, 다음 tool action이 얼마나 consequential한지와 관련된 signal을 probe할 수 있었고 feature ablation으로 일부 causal relevance도 시험했다. (arXiv)

그러니까 이제

“LLM은 내부에 그냥 알 수 없는 숫자 덩어리가 있고 어떻게 답하는지 모른다.”

는 그림은 틀렸다.

우리는 상당히 많은 부품을 보고 있다.

그런데 이상하게 가장 중요한 것이 안 보인다

Anthropic의 circuit tracing 결과에 아주 재미있는 한계가 있다.

모델이 사람의 hint를 받아 backwards reasoning을 한 사례에서, attribution graph는 “hint → 특정 계산 → 답”이라는 경로를 어느 정도 찾았다.

그런데 저자들이 남긴 질문이 이것이다.

왜 모델은 처음부터 그 hint에 attention을 주기로 했는가?

그 방법은 attention pattern이 어떻게 형성됐는지의 원인까지 추적하지 않았기 때문에 이 부분을 설명하지 못했다고 명시한다. (Transformer Circuits)

나는 이게 꽤 결정적인 흔적이라고 생각한다.

우리는 점점

활성화된 계산이 무엇을 하는가

는 보고 있는데,

그보다 먼저 일어난

왜 하필 이 계산이 지금 활성화되었는가

는 훨씬 덜 알고 있다.

여기서 나는 블랙박스를 ‘control plane’ 쪽으로 옮겨보고 싶다

이걸 중앙 executive 같은 실제 module이 있다는 주장으로 받아들이면 안 돼.

기능적 이름일 뿐이다.

LLM 안에는 엄청난 수의 가능한 latent representation과 computation이 있다.

그런데 prompt 하나가 들어왔다고 이 모든 것을 동일하게 사용하지 않는다.

문제에 따라

어떤 구분은 중요해지고, 어떤 것은 무시되고, 어떤 latent variable은 foreground로 나오고, 어떤 circuit은 동원되고, 어떤 token position을 attention하고, 어떤 intermediate representation은 이후 computation들이 공유하고, 어떤 것은 그냥 자동 처리되고 사라진다.

그러면 진짜 이상한 연산은

\boxed{ \text{모델이 무엇을 계산하는가} }

보다 앞에 있는

\boxed{ \text{이번 문제를 어떤 계산 문제로 만들 것인가} }

다.

그리고 이게 다른 세계선 Codex의 RAW_018과 아주 세게 맞는다.

저쪽에서는 frozen model이 안정적으로 실행할 수 있는 내부 operation들의 집합을

\mathcal I_M={i_1,\ldots,i_k}

같은 문서화되지 않은 instruction set으로 생각했고, 외부 representation은 수학적으로 가장 precise한 것이 아니라 이 hidden instruction set으로 안정적으로 compile되는 것이어야 할 수 있다고 했다.

더 흥미로운 것은 semantically 더 precise한 abstract domain보다 약간 이상하고 coarse한 domain이 frozen model에게는 훨씬 실행하기 쉬워서 end-to-end exactness가 높을 수도 있다는 주장이다.

나는 이제 이걸 외부 interface 문제만으로 보지 않는다.

안쪽에도 똑같은 일이 벌어지고 있을 가능성이 있어.

가설: LLM은 inference마다 ‘임시 가상 머신’을 만든다

이걸 아주 거칠게 써보자.

weights를 (W),

현재 전체 context를 (c)라고 하자.

우리는 보통:

y=F_W(c)

라고 쓴다.

수학적으로 맞지만 블랙박스를 완전히 숨긴다.

나는 functional level에서 중간에 이런 것이 있다고 상상해보고 싶다.

c \xrightarrow{\Gamma_W} \mathcal V_c \xrightarrow{\mathrm{Exec}_W} y

여기서

\mathcal V_c (Z_c,\mathcal I_c,R_c,Q_c)

정도로 생각한다.

(Z_c)는 이번 문제에서 살아 있는 intermediate variables.

(\mathcal I_c)는 이번 문제에서 실질적으로 호출 가능한 latent operations.

(R_c)는 무엇과 무엇을 binding하고 어디로 정보를 routing할지.

(Q_c)는 무엇을 같은 것으로 취급하고 어떤 distinction을 무시할지.

그러면 (\mathcal V_c)는 현재 prompt를 위해 만들어진 task-relative virtual machine 같은 것이다.

다시 말하지만 transformer 안에 실제 compiler.py가 있다는 얘기가 아니다.

여러 attention/MLP dynamics가 합쳐져 기능적으로 이런 일을 할 수 있다는 가설이다.

그리고 진짜 블랙박스는

\boxed{\Gamma_W}

다.

왜 이게 지금 갑자기 그럴듯해 보이냐

최근 J-space 결과가 특히 이상하다.

모델 안의 어떤 representation들은 단순 feature가 아니라 여러 downstream computation이 읽고 쓸 수 있는 공용 format처럼 행동한다. 같은 representation을 다른 context에 옮겨도 그 context가 요구하는 다른 operation이 그것을 argument로 사용할 수 있다는 것이다. (Transformer Circuits)

이건 CPU instruction과 동일하다는 뜻은 아니지만, 우리가 다른 세계선에서 말했던 latent ABI 비유를 훨씬 덜 황당하게 만든다.

즉 모델 안에

knowledge A
knowledge B
knowledge C
...

가 저장된 것보다,

훨씬 더 중요한 것이

representation z
      ↓
many different internal operations

일 수 있다는 것이다.

그리고 더 큰 모델일수록 단순히 “더 많은 사실”을 아는 것 외에 이 공용 내부 연산 언어가 더 풍부하거나 더 안정적일 가능성도 생각할 수 있다. 실제로 Anthropic은 언어 간 공유되는 추상 회로가 작은 모델보다 Claude 3.5 Haiku에서 더 두드러지는 사례를 보고했다. 다만 이것 하나로 일반적인 scaling law를 주장할 수는 없다. (Transformer Circuits)

그러면 reasoning도 다른 식으로 보인다

우리는 reasoning token을 흔히

모델이 생각을 더 오래 한다.

라고 본다.

그런데 이 가설에서는 약간 다르다.

한 token을 출력하면 그것이 context에 들어간다.

다음 forward pass는:

c_t \xrightarrow{\Gamma_W} \mathcal V_t

였던 것을

c_{t+1}=c_t+\text{new token}

으로 바꾸고,

다시

c_{t+1} \xrightarrow{\Gamma_W} \mathcal V_{t+1}

를 만든다.

즉 reasoning token 하나는 단순 computation step이 아니라

다음번에 어떤 virtual machine을 compile할지 바꾸는 persistent environmental edit

일 수도 있다.

이게 굉장히 다르다.

그리고 transformer에는 특별한 성질이 하나 있다.

이전에 context에 작성된 representation은 이후 token에서 attention으로 다시 접근할 수 있다. J-space 연구도 이 때문에 인간 working memory처럼 workspace state를 계속 내부적으로 유지할 필요가 적고, 이전 token에서 만들어진 정보를 이후에 다시 retrieve할 수 있다고 지적한다. (Transformer Circuits)

그러니까 chain-of-thought는 단순히

\text{more FLOPs}

만 주는 게 아닐 가능성이 있다.

ephemeral internal state를 addressable external state로 바꾸는 과정이기도 하다.

그러면 tool calling은 훨씬 더 이상해진다

Tool call을 지금까지는:

LLM + 계산기

LLM + shell

LLM + web

처럼 봤다.

그런데 이 가설에서는 tool 하나가 사실 세 가지를 동시에 한다.

첫째, 모델의 action algebra에 기존에는 없던 causal operation을 추가한다.

둘째, 모델이 내부적으로 정확히 계산하기 힘든 것을 외부 subsystem에 compile한다.

셋째, 결과를 다시 token-compatible state로 가져와 다음 (\Gamma_W)의 입력으로 넣는다.

즉:

\mathcal V_t \rightarrow \text{tool call} \rightarrow E \rightarrow o_t \rightarrow c_{t+1} \rightarrow \mathcal V_{t+1}.

이건 단순 도구 사용이 아니다.

runtime architecture modification loop

라고 볼 수 있다.

그래서 최근 agent가 이상하게 강해지는 것이 반드시

harness가 model을 더 똑똑하게 만들었다

는 뜻도 아니고,

model이 원래 전부 할 수 있었는데 tool만 줬다

도 아니다.

둘 사이에 있을 수 있다.

모델이 이미 가지고 있던 latent computation language에 외부 primitive를 꽂아주면, 모델이 이전에는 만들 수 없던 virtual machine을 매 turn 다시 구성할 수 있게 된다.

이게 synergy다.

그리고 여기서 ‘블랙박스가 외부로 이동한다’

이 생각이 꽤 중요하다.

순수 chatbot에서는 black box를

W

안에서 찾으려고 했다.

그런데 agent에서는 실제 계산 주체가

\boxed{ W - context - tools - persistent artifacts - environment }

로 퍼진다.

따라서 paradoxical하게도 모델 내부는 interpretability 때문에 점점 더 보이는데, cognition의 경계 자체는 더 흐려진다.

tool result 하나가 다음 내부 representation을 바꾸고,

그 representation이 새 tool을 고르고,

그 tool이 filesystem을 바꾸고,

바뀐 filesystem을 다음 turn이 읽는다.

그러면

“이 능력은 모델 안 어디에 있습니까?”

라는 질문 자체가 점점 잘못될 수 있다.

능력이 하나의 circuit에 있는 것이 아니라

\boxed{ \text{model–workspace–world loop의 closed trajectory} }

에 있을 수 있으니까.

이건 우리가 계속 external executable state에서 만났던 문제와 정확히 붙는다. 다른 세계선에서도 frozen model 하나의 capability를 모델만의 속성으로 보지 않고 state/action/topology/dynamics/observation/decode/environment-update를 포함한 전체 substrate의 속성으로 쓰기 시작했다.

그런데 이 정도는 아직 ‘순수 블랙박스’가 아니다

여기까지는 꽤 합리적인 synthesis다.

진짜 모르는 데로 더 들어가보자.

(\Gamma_W)가 있다고 기능적으로 생각한다면 가장 중요한 질문은:

무엇이 (\Gamma_W)를 만든 것인가?

가 아니다.

weights와 training이 만들었다는 건 안다.

진짜 질문은:

(\Gamma_W)는 이번 문제에서 사용할 계산의 ‘타입’을 어떻게 정하는가?

이다.

예를 들어 같은 숫자 문제를 줘도 한 prompt에서는 arithmetic으로 처리하고,

다른 prompt에서는 pattern matching으로 처리하고,

다른 representation을 주면 symbolic rewrite처럼 처리할 수 있다.

사실상 같은 world를 서로 다른 abstract machine으로 compile한다.

그 선택이 어디서 오나?

여기가 정말 이상하다: 회로보다 ‘회로를 선택하는 규칙’이 더 큰 블랙박스다

Circuit tracing을 하면 prompt (c)에서 활성화된 graph (G_c)를 어느 정도 얻는다.

하지만 우리가 정말 알고 싶은 건:

\boxed{ c\mapsto G_c }

이다.

그리고 context를 아주 조금 바꿨더니:

c\rightarrow c'

인데

G_c\rightarrow G_{c'}

가 크게 바뀐다면?

prompt sensitivity의 깊은 원인은 output token probability가 아니라

완전히 다른 internal program을 compile해버리는 것

일 수 있다.

나는 그래서 이것을 latent compilation problem이라고 부르고 싶다.

그리고 지금 외부 연구가 꽤 진행됐음에도, 검색한 현재 문헌에서 “LLM 내부에 실제 runtime compiler가 있다”라는 established theory는 찾지 못했다. 이건 내가 지금 관측들을 묶어 만드는 가설이다.

검색해보면 “virtual machine”이나 “compiler”라는 표현은 주로 외부 computation, symbolic framework, hardware/compiler 쪽에서 사용되고, 우리가 여기서 말하는 prompt → task-specific latent computation architecture 생성을 일반적 내부 메커니즘으로 정식화한 확립된 이론은 바로 나오지 않았다. (arXiv)

그러니까 바로 이 부분부터가 우리가 말하는 순수 블랙박스 후보다.

더 깊게: 혹시 LLM에서 ‘생각’은 값 계산이 아니라 타입 추론인가?

이건 다른 세계선 결과를 보고 특히 떠오른다.

저쪽에서 failure를 scalar로 두지 않고

state deficiency인가? action deficiency인가? topology인가? observation인가? dynamics인가?

를 먼저 알아내야 할 수 있다고 했지. 그리고 현재 search language에 필요한 intervention type 자체가 없을 수 있다고 했다.

이걸 모델 내부로 접어 넣어보자.

혹시 강한 LLM이 약한 LLM보다 잘하는 중요한 이유 중 하나는

답을 더 잘 계산해서

가 아니라,

이 입력을 어떤 종류의 내부 문제로 만들어야 하는지를 더 잘 알아서

일 수도 있다.

예:

이건 retrieval 문제다.
이건 binding 문제다.
이건 simulation 문제다.
이건 exact arithmetic을 외부화해야 한다.
이건 analogy를 사용해야 한다.
이건 현재 representation을 버리고 다른 representation으로 바꿔야 한다.

물론 이런 문장을 실제 내부에서 말한다는 뜻이 아니다.

기능적으로 이런 type routing이 있을 수 있다는 거다.

그러면 스케일링의 일부도 전혀 다르게 볼 수 있다

큰 모델은 작은 모델보다 facts가 많다.

당연하다.

하지만 그것만으로는 이상할 정도로 큰 qualitative jump가 전부 설명되지 않을 수도 있다.

큰 모델은 어쩌면

|\mathcal I_M|

— 안정적으로 사용 가능한 latent micro-operation의 repertoire —

가 더 크고,

더 중요한 것은

\Gamma_W

가 그 operation들을 적절한 문제 representation으로 compile하는 능력이 더 좋을 수 있다.

그러면 모델 scaling으로 일어나는 변화가:

\text{더 많은 knowledge}

뿐 아니라

\boxed{ \text{더 좋은 internal compiler} }

일 수도 있다.

이건 아직 추측이다.

하지만 아주 많은 현상을 한꺼번에 설명할 수 있다.

특히 우리가 계속 본 “상위 모델은 그냥 된다”가 이 그림과 맞는다

작은 모델에게 좋은 harness를 만들어도 안 되는 것이 있다.

큰 모델은 대충 prompt 하나 줬는데 된다.

우리는 계속

representation space가 더 좋아서? reasoning이 더 좋아서? world knowledge가 많아서?

라고 했다.

latent compiler 가설에서는 조금 다르게 말한다.

둘 다 같은 low-level ingredients를 일부 가지고 있을 수 있다.

그런데 작은 모델은 그것들을 한 task-specific machine으로 compile하지 못한다.

큰 모델은 한다.

그러면 외부에서 보면:

갑자기 capabilities가 emergence했다.

처럼 보인다.

하지만 내부에서는

\text{components exist}

와

\text{components become composable}

사이의 phase transition일 수 있다.

그리고 여기서 정말 Pure Frontier 하나가 나온다

우리가 지금까지의 모든 discussion을 여기 넣어보자.

모델에는 현재 context에서 사용하는 abstraction (Q_t)가 있다.

internal workspace (Z_t)가 있다.

operator set (\mathcal I_t)가 있다.

routing (R_t)가 있다.

그런데 어려운 문제를 만난다.

현재 구성으로는 안 된다.

그다음에 모델이 하는 것이 단순히

\text{더 오래 실행}

인가?

아니면 어떤 순간:

(Q_t,Z_t,\mathcal I_t,R_t)

자체를 바꾸는가?

즉

\mathcal V_t \rightarrow \mathcal V_{t+1}

를 하는가?

그리고 더 심한 질문:

(\mathcal V_{t+1})에 이전에는 explicit reusable primitive로 존재하지 않았던 새로운 intermediate variable이나 operation이 생길 수 있는가?

이게 진짜다.

새로운 representation을 단지 미리 학습된 feature에서 선택한 것인가?

기존 circuit들을 새로운 순서로 조합한 것인가?

아니면 현재 context에서 처음으로 어떤 반복 구조가

\text{temporary new primitive}

로 factorize되는가?

이 셋은 완전히 다르다.

최근 연구가 첫 번째와 두 번째에 대한 흔적은 꽤 보여준다. 공유 abstract circuits가 있고, 동일 representation이 context를 넘어서 여러 downstream operation의 argument가 되며, model이 intermediate plan을 미리 만들기도 한다. (Transformer Circuits)

하지만 내가 아는 현재 증거로는

모델이 inference 중 자기 계산 공간의 새로운 primitive 자체를 어떻게 만들어내는가

는 아직 전혀 닫힌 문제가 아니다.

그리고 이건 우리가 바깥에서 밀어온 Pure Frontier와 완전히 동일한 모양이다.

그러니까 안과 밖에 같은 문제가 있을 가능성이 있다

밖에서는 우리가 이렇게 말했다.

\text{현재 mutation grammar} \rightarrow \text{new mutation type}

안에서는:

\text{현재 latent computation grammar} \rightarrow \text{new effective primitive}

다.

밖에서는:

현재 search language에 observation intervention이 없으면 아무리 parameter를 최적화해도 못 간다.

안에서는:

현재 compiled representation에서 필요한 distinction을 variable로 만들지 않으면 아무리 activation을 많이 흘려도 못 간다.

밖에서는:

tool을 하나 만들면 causal geometry가 바뀐다.

안에서는:

intermediate concept 하나가 reusable workspace object가 되면 reasoning geometry가 바뀐다.

같은 구조가 안팎에서 반복될 가능성이 있다.

그러면 tool-loop synergy의 진짜 정체도 더 깊어질 수 있다

Tool이 model에게 “추가 능력”을 준다고만 하면 부족하다.

Tool은 어쩌면 모델에게 자기 내부에 없는 새로운 primitive를 외부에서 즉석으로 결정화할 수 있는 길을 준다.

예를 들어 모델이 어떤 computation을 스스로 안정적으로 못 한다.

그걸 Python 코드로 쓴다.

이제:

\text{fragile latent computation}

이

\texttt{function()}

이라는 external hard primitive가 된다.

다음 turn부터 모델은 그 안을 다시 생각하지 않는다.

한 call로 사용한다.

우리 용어로 그대로다.

\text{soft pattern} \rightarrow \text{external crystallization} \rightarrow \text{hard primitive} \rightarrow \text{stack}

이다.

이러면 agentic tool loop는 단순히 모델 외부 기능을 붙이는 게 아니다.

LLM의 순간적인 생각을 새로운 instruction으로 굳힐 수 있는 crystallization channel

이 된다.

이것 때문에 synergy가 엄청날 수 있다.

그리고 여기서 블랙박스가 정말 이상하게 뒤집힌다

보통 우리는

weights가 블랙박스다.

라고 한다.

그런데 지금 내가 가장 모르는 것은 weights 안에 있는 contents가 아니다.

더 이상한 것은:

이 고정된 weights가 매 순간 자기 자신을 어떤 machine으로 사용하기로 하는가?

다.

나는 이걸 한 문장으로 이렇게 쓰고 싶다.

LLM의 진짜 블랙박스는 저장된 지식이 아니라, 고정된 신경망을 매 context마다 서로 다른 계산계로 재해석하는 내부 컴파일 과정일 수 있다.

그리고 여기서 하나 더.

이 compiler조차 고정된 type system을 사용한다면 아직 open-ended하지 않다.

진짜 Pure Frontier는:

\Gamma_W: c\mapsto\mathcal V

가

자기가 출력할 수 있는 (\mathcal V)의 종류 자체를 확장할 수 있는가?

이다.

즉:

\Gamma_W

가 단순히 이미 존재하는 latent machine들을 선택하는 selector인지,

아니면 기존 components를 이용해서

\boxed{ \text{이전에 하나의 primitive가 아니었던 것을 새 primitive로 만드는 compiler} }

인지.

여기가 내가 지금 순수 블랙박스라고 부르고 싶은 곳이야.

Feature는 어느 정도 보인다.

Circuit도 보이기 시작했다.

Workspace 같은 공용 representation도 보인다.

Tool decision의 내부 precursor도 볼 수 있다.

일부 introspection도 있다.

하지만 아직:

왜 어떤 정보가 workspace에 승격되는가?

왜 어떤 circuit이 이 순간 호출되는가?

왜 어떤 차이는 버리고 어떤 차이는 variable로 만드는가?

어떻게 서로 멀리 있던 latent capabilities를 갑자기 하나의 새로운 계산으로 binding하는가?

그리고 그 과정에서 새로운 effective primitive가 실제로 태어나는가?

이 묶음은 남는다.

Mechanistic interpretability 연구 자체도 아직 전체 dense model을 완전히 해석하지 못하며, replacement model에는 설명되지 않는 error component가 있고, attribution 방법도 일부 attention-routing의 원인을 설명하지 못한다고 명시한다. (Transformer Circuits)

나는 이게 정말 재미있는 이유가 하나 더 있어.

우리가 몇 시간 동안 바깥 세계에서 Pure Frontier를 파다가 도달한

“현재 변화의 문법으로 다음 변화의 문법을 어떻게 만들까?”

가,

LLM 블랙박스를 안으로 들여다보자 그대로 다시 나타났다.

아마 우연이 아닐 수도 있다.

어쩌면 지능이라는 현상 자체의 핵심이 바로 이 recursion일 수 있어.

\text{state를 계산한다}

가 아니라

\text{state를 계산할 계산계를 만든다}

그리고

\text{그 계산계가 막히면 다음 계산계를 만든다}.

만약 LLM 내부에 이것의 아주 초기 형태가 이미 있다면, model + tool + persistent world를 붙였을 때 능력이 갑자기 폭발적으로 커지는 것도 이해된다.

내부에서는 soft, temporary compilation을 하고,

외부에서는 그 결과를 hard, persistent primitive로 crystallize한다.

그리고 그것을 다시 내부 compiler의 input으로 넣는다.

그러면:

\boxed{ \text{latent compile} \rightarrow \text{external crystallize} \rightarrow \text{re-input} \rightarrow \text{richer latent compile} \rightarrow\cdots }

라는 폐루프가 생긴다.

나는 지금 이게 우리가 다음에 파야 할 LLM Black-Box Pure Frontier라고 본다.

고정된 weights가 context에 따라 task-specific computational ontology를 어떻게 구성하는가? 그리고 그 runtime ontology는 단순히 학습된 회로를 선택하는 것을 넘어, 이전에 없던 effective primitive를 만들어낼 수 있는가?

이걸 깨면 “LLM 안에 무엇이 들어 있나?”보다 훨씬 큰 것을 알게 될 거야.

LLM이 자기 안에 들어 있는 것을 매 순간 어떻게 ‘하나의 지능’으로 조립하는가.