跟讀練習: Context Engineering for AI Agents: 4 Failure Modes to Avoid - 通過影片學習英語口語

選擇練習模式

每種模式都會開啟全屏練習室。

116 句
如果句子過短或過長,請點選 Edit 進行調整。
1
context windows have grown from well a few thousand tokens to well a lot bigger like a million
2
or more and that's room for more stuff more instructions tool results docs you name it
3
so if we think about ai agents
4
and we give them access to this big old context window well
5
they should probably be getting better at long -running tasks shouldn't they?
6
I mean the more context the better job they can do.
7
Well a recent study looked at 18 frontier models
8
and it turned out that they all got less reliable as the context window got bigger.
9
Researchers have taken to giving this thing a name and that is context rot.
10
The more tokens in the window the less reliably the model uses any of them.
11
And this is the problem that context engineering is there to solve.
12
Context engineering is deciding what actually goes into this context window at each step of an agent's run.
13
Now there are many ways an agent's context can go wrong and I'm going to cover four of them.
14
The four failure modes that you can encounter when working with these big context windows.
15
And because I'm feeling nice I'll also suggest how to fix each one.
16
And the funny thing about those fixes is they involve deliberately throwing away information.
17
So how does an agent get better by holding less context?
18
Well to answer that we should first take a look at what's actually filling up these giant context windows.
19
So let's say an AI agent was given the job to migrate an aging code base over to a new database driver.
20
So I'm talking about here we are building a migration AI agent.
21
Now at the beginning of the context window the first thing most likely in here is the system prompt.
22
That's the standing instructions for how the agent operates in general.
23
Now the agent task itself
24
that will also be stored in here as well just as a prompt on its own
25
and it might not be very big it might only be a couple of lines.
26
Then many agent harnesses also pull in a bunch of project instructions.
27
Now these are things like an agents .md file explaining how this particular project is built.
28
Then after that we might have some tool definitions, a description of every tool the agent can call.
29
And from here on in the context window turns into a bit of a running log
30
so we're going to have a message history here this is every step the the agent has taken
31
and after let's say an hour of running well
32
this could get pretty big that's going to be a lot of steps
33
and then the biggest band is probably the tool results
34
that we store here which is things like file contents
35
and test output and error logs and schema dumps
36
so the job description the prompt is a few lines near the front
37
and pretty much everything else is the stuff
38
that the agent kind of piles up along the way oh
39
and buried in this as well there happens to be a note
40
this is a note the agent wrote itself it says
41
that the new driver retries failed connections automatically
42
so the old retry code can be deleted
43
so the note just basically says hey don't bother with writing any retry code why do i mention
44
that we'll come back to
45
that anyway why is a full context window a problem well
46
a model doesn't look things up in its context the way
47
a database looks up a row every token in the window
48
is competing for a finite amount of attention essentially an attention budget.
49
And to me, this is kind of the crux of it.
50
The window might hold a million tokens, but the attention spread across those tokens is finite.
51
Now, what about those failure modes?
52
Let's start with the first one.
53
Number one, that is context poisoning.
54
So I cryptically mentioned the agent wrote itself a note about the new driver retrying failed connections automatically.
55
Well it turns out that that note is completely wrong.
56
The agent shouldn't have done this.
57
It basically skim the driver's documentation, it misread it, and then it's written down a false conclusion.
58
And that's all poisoning is.
59
A mistake gets into this context window somewhere and then gets treated as fact because to the AI model,
60
its own notes, they look like the ground truth.
61
So file after file, our agent has been deleting perfectly good retry code.
62
Next, number two, that is context distraction.
63
This is where the sheer size of the history starts steering the agent.
64
Now a language model at its heart is just a pattern continuation machine
65
and when the context holds at say an hour of an agent's own past actions, that history becomes pretty much the strongest pattern around,
66
stronger than the reasoning it picked up in training.
67
So instead of asking what the job needs next the model
68
might drift into doing more of what it has already done
69
in this message history agents in this state can get stuck just kind of going over old ground
70
what about number three that is context confusion
71
and this one comes from the tools our agent here is wired into quite a lot of stuff
72
there's probably some amount of version control here
73
it might be access to a database console maybe it also is logging tickets into a ticketing system
74
and each of these tool definitions is in the window whether it actually gets used
75
or not and having more of them makes choosing the right tool a bit harder
76
and in one benchmark a model failed a task
77
when it was offered 46 tools but it then passed the very same task
78
when it was only offered 19 tools
79
that is tool sprawl work okay number four that is context clash
80
which is when the window contains information that disagrees with itself
81
so take that note with the bad information at some point our agent is going to see
82
that no retries are happening and it's going to figure out
83
that that note was wrong and it will probably make a note of
84
that into its message history as well
85
but the problem then is we now have both versions sitting in the window
86
that are presenting conflicting information so these are four different ways a context window can go bad
87
all right so what about some potential fixes well for poisoning one of the fixes is to validate.
88
Before a conclusion gets written down into this context window, check it against something real.
89
So one quick connection test and our agent would never have written this no retry code note.
90
What about distraction?
91
Well, the fix there is really too compact.
92
When the history gets really, really long, the agent can summarize it,
93
which is to say it throws the full log away and starts again from the summary,
94
a shortened version of what was in this message history in the window.
95
Now compaction is lossy.
96
A summary of a summary can start to drift like a photocopy of a photocopy.
97
So consider moving as much out of the context window as possible and put them into permanent files instead.
98
Detailed information can be retained in those files, and then it can be pulled into the context window only when it's actually needed.
99
All right, what about context confusion?
100
Well, that is a curation problem, so the fix is to curate.
101
The agent doesn't need 46 tools for database migration, so just give it the handful that the job calls for,
102
and then it can always go and fetch others
103
if it actually needs them then finally context clash well the fix there can be to prune so
104
when information gets superseded just delete the old version rather than leaving both in the window
105
we could have deleted this guy entirely or go further
106
and start a fresh window just restating the current corrected state of the job
107
and leave the poison stuff behind so
108
if a false conclusion gets saved that's poisoning so you can validate
109
if the history has taken over that's distraction so compact
110
if the agent has more tools than the task needs that's confusion
111
so curate and if the context disagrees with itself that's a clash and the fix is prune.
112
And all four fixes work by throwing something away.
113
An agent can get better at long tasks by holding less.
114
Now I'd love to know how you keep an agent's context lean.
115
Do you have your own context engineering fixes?
116
Let me know in the comments.

下載應用

流利口語所需的一切

AI 發音評分逐句打分
音標練習掌握每個音
詞彙學習建立你的詞庫
詞彙遊戲邊玩邊學

同頻道

FOR YOU

推薦影片

本課的詞彙與口語要點

這節口語課以影片“Context Engineering for AI Agents: 4 Failure Modes to Avoid”為素材。 影片中反覆出現的詞有:context, agent, window, tool, note。 這段影片共有 100 個句子、1451 個單詞可供跟讀。 講話部分時長為 10:08。 說話人語速平穩,每分鐘約 143 個詞,很適合跟讀。 86% 的單詞屬於英語最常用的 3,000 詞,其餘的詞建議在練習前先學一下。

影片中的重點詞彙

影片中 15 個值得學習的單詞,附發音和釋義:

單詞發音釋義
poison 名詞/ˈpɔɪ.zən/毒, 毒物
token 名詞/ˈtoʊkən/代幣 /代幣, 籌碼 /籌碼
database 名詞/ˈdeɪtəˌbeɪs/資料庫 /資料庫
delete 動詞/dɪˈliːt/刪除 /刪除
conclusion 名詞/kənˈkluːʒən/結束 /結束
summary 名詞/ˈsʌm.ə.ɹi/摘要
confusion 名詞/kənˈfjuːʒən/混亂 /混亂
instruction 名詞/ɪnˈstɹʌkʃən/教導 /教導
clash 名詞/ˈklæʃ/錚錚 /錚錚
log 名詞/lɔɡ/圓木 /圓木
migration 名詞/maɪˈɡɹeɪʃ(ə)n/徙動 /徙動, 遷移 /遷移
disagree 動詞/dɪsəˈɡɹi/不同意, 反對 /反對
compact 形容詞/kəmˈpækt/緊湊的 /緊湊的
finite 形容詞/ˈfaɪ.naɪt/有限的
output 名詞/ˈaʊtpʊt/輸出 /輸出

影片中出現的短語動詞

單詞發音釋義
turn out 動詞原來 /原來
figure out 動詞弄清楚
fill up 動詞裝滿 /裝滿
look up 動詞/ˌlʊk ˈʌp/仰, 上看
take over 動詞接管, 接手
throw away 動詞棄置 /棄置, 扔
write down 動詞寫下來 /寫下來, 寫下 /寫下

影片中的語法

說話人最常用的結構,並附上影片中的原話:

結構影片中的用法
被動語態 be + 過去分詞 — 強調發生了什麼,而不是誰做的was given · be stored · is built
現在完成時 have/has + 過去分詞 — 過去發生但與現在仍有關聯的事have grown · have taken · has taken

需要注意的發音

說話人用了 12 次縮略和弱讀形式,例如 doesn't, gonna, I'm。請按聽到的簡短形式來說。

  • “sh” 和 “zh” 音: conclusion /kənˈkluːʒən/, confusion /kənˈfjuːʒən/, instruction /ɪnˈstɹʌkʃən/, clash /ˈklæʃ/, distraction /dɪsˈtɹæk.ʃən/
  • 長單詞——注意重音位置: essentially /ɪˈsɛnʃəli/, deliberately /dɪˈlɪb.(ə.)ɹət.li/, documentation /ˌdɑkjəmɛnˈteɪʃən/, continuation /kənˌtɪnjʊˈeɪʃ(ə)n/, photocopy /ˈfəʊtəˌkɒpi/

中文母語者容易讀錯的音:

  • /v/ — 不要讀成 /w/,上齒輕觸下唇: solve /sɒlv/, involve /ɪnˈvɑlv/, validate /ˈvæl.ɪ.deɪt/
  • 詞尾子音 — 要讀清楚,後面不要加母音: database /ˈdeɪtəˌbeɪs/, delete /dɪˈliːt/, clash /ˈklæʃ/, prompt /pɹɑmpt/, log /lɔɡ/
  • /r/ 和 /l/ 的區別: reliable /ɹɪˈlaɪəbl̩/, deliberately /dɪˈlɪb.(ə.)ɹət.li/, sprawl /spɹɔːl/

如何用這段影片練習

  1. 先完整聽一遍影片,不要開口,記下不認識的單詞。
  2. 用正常速度逐句跟讀,每句重複到你的節奏與說話人一致為止。
  3. 錄下自己的聲音並與原聲對比,特別注意 poison, token, database 這類單詞。

什麼是跟讀法?

跟讀法 (Shadowing) 是一種有科學依據的語言學習技巧,最初開發用於專業口譯員的培訓,並由多語言者Alexander Arguelles博士普及。這個方法簡單而強大:您在聽英語母語原聲的同時立即大聲重複——就像是一個延遲1-2秒緊跟說話者的影子。與被動聽力或語法練習不同,跟讀法強迫您的大腦和口腔肌肉同時處理並模模擬實的講話模式。研究表明它能顯著提高發音準確性,語調,節奏,連讀,聽力理解和口語流利度——使其成為雅思口語備考和真實英語交流最有效的方法之一。

影子跟讀法: 閱讀完整分步指南 →