서론
2024년, GPT-4o가 bar exam 상위 10% 성적을 받고, Claude 3.5 Sonnet이 복잡한 코딩 과제를 해결하는 시대가 왔다. 그런데 왜 여전히 “AI가 진짜로 똑똑해졌는지"를 묻는 질문에 답하기가 이토록 어려울까?
필자가 속한 연구실에서 최근 흥미로운 실험을 진행했다. 최신 LLM에게 “처음 보는 규칙 기반 보드게임을 플레이하라"는 과제를 주었더니, 모델은 게임 규칙을 완벽하게 설명했지만 실제 플레이에서는 일관성 없는 행동을 반복했다. 이것이 현재 AI 벤치마크의 핵심 한계다. 정적인 지식을 평가할 뿐, 동적인 환경에서의 적응 능력은 측정하지 못한다.
François Chollet이 2019년 처음 제안한 ARC(Abstract Reasoning Challenge)는 이 문제를 직면했다. 그리고 2025년, ARC-AGI-3는 한 걸음 더 나아간다. 단순히 정답을 맞히는 것이 아니라, 환경을 탐색하고, 규칙을 발견하고, 시행착오를 통해 학습하는 능력을 평가하는 최초의 상호작용형 벤치마크다.
이 글에서는 ARC-AGI-3의 핵심 설계 철학, 기술적 메커니즘, 그리고 이것이 왜 AGI 연구에 새로운 패러다임을 제시하는지 깊이 있게 분석한다.
기존 벤치마크의 한계와 ARC-AGI의 등장
정적 벤치마크의 Problem of Contamination
MMLU, HumanEval, GSM8K 같은 전통적 벤치마크는 “오염 문제(Contamination Problem)“에 시달린다. 모델이 학습 데이터에 포함된 문제를 단순히 기억해서 푸는 것인지, 진짜로 추론 능력을 갖춘 것인지 구분할 수 없다.
1
2
3
4
5
6
7
8
9
10
| # 전통적 벤치마크의 한계를 보여주는 예시
# 모델이 학습 데이터에서 본 문제
training_example = """
Q: What is 15 * 23?
A: 345
"""
# 테스트 시간에 동일한 문제 출제
test_question = "What is 15 * 23?"
# 모델은 추론이 아니라 "기억"으로 답할 수 있음
|
Chollet은 2019년 논문 “On the Measure of Intelligence"에서 이 문제를 정면으로 다루었다. 진정한 지능은 **“이전에 본 적 없는 과제에 대한 일반화 능력”**이라고 정의했다. 이 철학이 ARC의 출발점이다.
ARC-AGI-1에서 ARC-AGI-3까지의 진화
| 버전 | 출시 연도 | 핵심 특징 | 한계점 | | :— | :— | :— | :— | | ARC-AGI-1 | 2019 | 정적 그리드 변환 과제 | 단일 정답, 탐색 불가 | | ARC-AGI-2 | 2024 | 난이도 계층화, 공개 테스트 셋 | 여전히 정적 구조 | | ARC-AGI-3 | 2025 | 상호작용형 환경, 시간 기반 학습 측정 | 에이전트 아키텍처 요구 |
ARC-AGI-3의 핵심 설계 원리
1. 상호작용형 환경 (Interactive Environment)
ARC-AGI-3의 가장 큰 혁신은 에이전트가 환경과 상호작용할 수 있다는 점이다. 더 이상 입력→출력의 단방향 구조가 아니다.
1
2
3
4
5
6
7
| graph LR
A[Agent] -->|Action| B[Environment]
B -->|Observation| A
A -->|Hypothesis| C[Internal Model]
C -->|Test Action| B
B -->|Feedback| C
C -->|Update| D[Refined Strategy]
|
에이전트는 환경을 탐색하고, 행동의 결과를 관찰하며, 자신의 가설을 수정한다. 이것이 진정한 의미의 “학습"이다.
2. 인간 해결 가능성 (Human Solvability)
모든 ARC-AGI-3 과제는 지식을 전제하지 않는다. 프로그래밍 경험, 수학 지식, 언어 능력 없이도 인간이 해결할 수 있는 순수 패턴 인식 과제다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| # ARC-AGI-3 과제의 예시 구조
class ARCAGI3Task:
def __init__(self):
self.environment = GridEnvironment()
self.max_steps = 100 # 탐색 가능한 스텝 수
self.goal_state = None # 명시적으로 주어지지 않음
def step(self, action):
"""행동을 취하고 관찰을 반환"""
observation = self.environment.apply(action)
return observation
def evaluate(self):
"""에이전트가 규칙을 '이해'했는지 평가"""
# 새로운 상황에서 일반화 능력 테스트
pass
|
3. 시간 기반 기술 습득 측정 (Skill Acquisition Over Time)
필자가 가장 흥미롭게 본 기능이다. ARC-AGI-3은 에이전트가 시간이 지남에 따라 성능이 향상되는지를 측정한다.
1
2
3
4
5
6
7
8
| graph TD
A[Episode 1] --> B[Random Exploration]
B --> C[Episode 10]
C --> D[Pattern Recognition]
D --> E[Episode 50]
E --> F[Efficient Strategy]
F --> G[Episode 100]
G --> H[Near-Optimal Performance]
|
이것이 왜 중요한가? 진정한 지능은 “처음 보는 문제를 바로 푸는 것"이 아니라, **“경험을 통해 효율적으로 개선되는 것”**이기 때문이다.
ARC-AGI-3 과제 구조 심층 분석
그리드 환경과 액션 스페이스
ARC-AGI-3의 환경은 2D 그리드로 구성된다. 각 셀은 0-9 사이의 정수(색상)를 가진다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
| import numpy as np
class GridEnvironment:
"""
ARC-AGI-3의 기본 그리드 환경
"""
def __init__(self, height=10, width=10):
self.grid = np.zeros((height, width), dtype=int)
self.action_space = [
'paint', # 셀 색상 변경
'copy', # 영역 복사
'rotate', # 회전
'flip', # 대칭
'fill', # 영역 채우기
'detect_pattern' # 패턴 감지 (특수 액션)
]
def apply_action(self, action_type, params):
"""
액션을 적용하고 새로운 그리드 상태 반환
Args:
action_type: 액션 종류
params: 액션 파라미터 (좌표, 색상 등)
Returns:
new_grid: 액션 적용 후 그리드
reward: 환경으로부터의 피드백
"""
if action_type == 'paint':
x, y, color = params
self.grid[y, x] = color
return self.grid.copy(), self._compute_feedback()
elif action_type == 'copy':
src_region, dst_region = params
# 영역 복사 로직
pass
# 기타 액션들...
def _compute_feedback(self):
"""
환경이 에이전트에게 제공하는 암시적 피드백
(명시적 reward가 아닌 observation 기반)
"""
# 예: 대칭성 위반 시 시각적 단서 제공
pass
|
규칙 발견 메커니즘
ARC-AGI-3 과제에서 성공하려면 에이전트는 다음 단계를 거쳐야 한다:
- Exploration Phase: 무작위 행동으로 환경 반응 관찰 2. Hypothesis Generation: 관찰된 패턴으로 규칙 가설 형성 3. Testing Phase: 가설을 검증하는 의도적 행동 수행 4. Refinement Phase: 실패 시 가설 수정 5. Application Phase: 학습된 규칙을 새로운 상황에 적용
1
2
3
4
5
6
7
8
9
10
11
12
13
| graph TD
A[Exploration] --> B[Observation Collection]
B --> C[Hypothesis Generation]
C --> D[Deliberate Testing]
D --> E{Hypothesis Valid?}
E -->|No| F[Refinement]
F --> C
E -->|Yes| G[Rule Extraction]
G --> H[Novel Situation Test]
H --> I{Generalization?}
I -->|No| J[Overfitting Detection]
J --> C
I -->|Yes| K[Success]
|
ARC-AGI-3 에이전트 구현 가이드
기본 아키텍처
ARC-AGI-3에서 경쟁력 있는 에이전트를 만들기 위해서는 전통적인 LLM 접근법으로는 부족하다. 다음은 필자가 제안하는 아키텍처다:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
| import torch
import torch.nn as nn
from transformers import AutoModelForCausalLM, AutoTokenizer
class ARCAGI3Agent(nn.Module):
"""
ARC-AGI-3를 위한 하이브리드 에이전트
LLM + Program Synthesis + Memory System
"""
def __init__(self, model_name="Qwen/Qwen2.5-7B-Instruct"):
super().__init__()
# 언어 모델 (추론 및 가설 생성)
self.llm = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype=torch.bfloat16
)
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
# 메모리 시스템 (경험 저장)
self.episodic_memory = []
self.semantic_memory = {} # 학습된 규칙 저장
# 프로그램 합성 모듈
self.dsl_parser = ARCDSLParser()
def observe(self, grid_state):
"""환경 관찰을 내부 표현으로 변환"""
# 그리드를 텍스트 설명으로 변환
description = self._grid_to_description(grid_state)
return description
def hypothesize(self, observations):
"""관찰로부터 규칙 가설 생성"""
prompt = self._build_hypothesis_prompt(observations)
inputs = self.tokenizer(prompt, return_tensors="pt")
outputs = self.llm.generate(**inputs, max_new_tokens=512)
hypothesis = self.tokenizer.decode(outputs[0])
return self._parse_hypothesis(hypothesis)
def act(self, hypothesis, current_state):
"""가설에 기반한 행동 선택"""
# 가설을 DSL 프로그램으로 변환
program = self.dsl_parser.compile(hypothesis)
# 프로그램 실행으로 행동 결정
action = program.execute(current_state)
return action
def update_memory(self, experience):
"""경험을 메모리에 저장하고 규칙 추출"""
self.episodic_memory.append(experience)
# 성공적인 경험에서 규칙 추출
if experience['success']:
rule = self._extract_rule(experience)
self.semantic_memory[rule.id] = rule
def _grid_to_description(self, grid):
"""그리드를 자연어 설명으로 변환"""
lines = []
lines.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
| append(f"Grid size: {grid.shape[0]}x{grid.shape[1]}")
# 색상 분포
unique, counts = np.unique(grid, return_counts=True)
color_dist = dict(zip(unique, counts))
lines.append(f"Color distribution: {color_dist}")
# 대칭성 감지
if self._check_symmetry(grid, 'horizontal'):
lines.append("Horizontal symmetry detected")
if self._check_symmetry(grid, 'vertical'):
lines.append("Vertical symmetry detected")
# 패턴 감지
patterns = self._detect_patterns(grid)
for p in patterns:
lines.append(f"Pattern: {p}")
return "
".join(lines)
def _build_hypothesis_prompt(self, observations):
"""가설 생성을 위한 프롬프트 구성"""
memory_context = self._get_relevant_memories(observations)
prompt = f"""You are solving an ARC-AGI-3 task.
Your goal is to discover the hidden rule governing this environment.
Previous Observations:
{observations}
Relevant Past Experiences:
{memory_context}
Generate a hypothesis about the rule. Format:
RULE: <description>
CONFIDENCE: <0-1>
TEST_ACTION: <suggested action to verify>
Hypothesis:"""
return prompt
|
Step-by-Step 학습 전략
ARC-AGI-3에서 좋은 성과를 얻기 위한 실전 가이드:
Step 1: 체계적 탐색 (Systematic Exploration)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| def systematic_exploration(env, num_episodes=10):
"""
초기 탐색 단계
다양한 액션을 시도하여 환경 반응 데이터 수집
"""
experiences = []
for episode in range(num_episodes):
state = env.reset()
for step in range(env.max_steps):
# 다양한 액션 타입 시도
action_type = ACTION_TYPES[step % len(ACTION_TYPES)]
# 랜덤 파라미터 생성
params = generate_random_params(env.grid_size)
# 액션 실행 및 관찰
new_state, done = env.apply_action(action_type, params)
# 경험 저장
experiences.append({
'state': state.copy(),
'action': (action_type, params),
'next_state': new_state.copy(),
'episode': episode
})
state = new_state
return experiences
|
Step 2: 패턴 마이닝 (Pattern Mining)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| from collections import Counter
def mine_patterns(experiences):
"""
수집된 경험에서 반복 패턴 발견
"""
# 상태 변환 패턴 분석
transformations = []
for exp in experiences:
diff = exp['next_state'] - exp['state']
transformations.append(diff)
# 빈번한 변환 패턴 찾기
pattern_counter = Counter(map(tuple, transformations))
frequent_patterns = pattern_counter.most_common(5)
return frequent_patterns
|
Step 3: 규칙 검증 (Rule Verification)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| def verify_rule(env, rule, num_tests=5):
"""
발견된 규칙이 일반화 가능한지 검증
"""
successes = 0
for _ in range(num_tests):
state = env.reset()
predicted_next = rule.predict(state)
actual_next = env.apply_action(rule.action)
if np.array_equal(predicted_next, actual_next):
successes += 1
return successes / num_tests
|
성능 비교 및 분석
현재 SOTA 모델들의 ARC-AGI-3 성능
| 모델 | ARC-AGI-1 | ARC-AGI-2 | ARC-AGI-3 (초기) | 특징 | | :— | :—: | :—: | :—: | :— | | GPT-4o | ~5% | ~12% | ~3% | 정적 추론에 강점 | | Claude 3.5 Sonnet | ~21% | ~18% | ~7% | 코드 생성 능력 활용 | | o1-preview | ~25% | ~21% | ~11% | Chain-of-thought 강화 | | 인간 평균 | ~85% | ~78% | ~72% | 탐색적 학습 능력 |
필자의 분석에 따르면, ARC-AGI-3에서 모델 간 격차가 더 벌어지는 이유는 “탐색 효율성” 때문이다. 인간은 10-20회의 시도만으로 규칙을 파악하지만, 현재 AI는 수백 회의 무작위 탐색을 필요로 한다.
핵심 도전 과제
- Sample Efficiency: 적은 경험으로 규칙 학습 2. Credit Assignment: 어떤 행동이 성공에 기여했는지 파악 3. Compositional Generalization: 학습된 규칙의 조합적 적용 4. Meta-Learning: “어떻게 학습할지"를 학습
결론
ARC-AGI-3는 단순한 또 다른 벤치마크가 아니다. 이것은 “AI가 얼마나 똑똑한가"라는 질문을 “AI가 얼마나 잘 배울 수 있는가"로 재정의한다.
필자가 연구실 동료들과 자주 토론하는 주제가 있다. “2025년의 AI는 2019년의 AI보다 똑똑한가, 아니면 그저 더 많이 알고 있는가?” ARC-AGI-3는 이 질문에 대한 객관적 답을 제공한다. 정적 지식이 아닌, 동적 학습 능력을 측정하기 때문이다.
핵심 요약
- 상호작용형 평가: 환경 탐색과 적응 학습 능력 측정 2. 인간 해결 가능성: 선행 지식 없이 순수 추론만으로 해결 가능 3. 시간 기반 측정: 경험에 따른 성능 향상 추적 4. 일반화 테스트: 학습된 규칙의 새로운 상황 적용 능력 평가
전문가 인사이트
ARC-AGI-3를 연구하면서 필자가 발견한 흥미로운 점은 **“좋은 에이전트는 좋은 탐색자”**라는 사실이다. 최고 성능을 보이는 에이전트들은 무작위 탐색이 아니라, 가설 기반의 체계적 탐색을 수행했다. 이것은 인간의 과학적 방법론과 놀라울 정도로 유사하다.
앞으로 ARC-AGI-3 연구가 가져올 가장 큰 임팩트는 Meta-Learning과 Program Synthesis의 융합일 것이다. 환경과 상호작용하면서 자신의 프로그램을 수정하는 자기 개선형 AI는 AGI로 가는 중요한 이정표가 될 것이다.
참고 자료
이 글은 ARC-AGI-3의 기술적 세부사항과 구현 가이드를 중심으로 작성되었습니다. 실제 대회 참가나 연구에 활용하실 때는 공식 문서와 최신 논문을 반드시 참고하시기 바랍니다.
출처: https://news.hada.io/topic?id=27890