@lmmslab/harness 0.85.1 → 0.86.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +1 -1
- package/python/harness/__init__.py +2 -2
- package/python/harness/bench.py +2 -2
- package/python/harness/builtin/benches/README.md +1 -2
- package/python/harness/builtin/configs/default.toml +4 -19
- package/python/harness/builtin/configs/deploy/example-api.toml +1 -1
- package/python/harness/builtin/configs/models/deepseek-flash.toml +1 -1
- package/python/harness/builtin/configs/models/grok-low.toml +1 -1
- package/python/harness/builtin/configs/models/grok-medium.toml +3 -6
- package/python/harness/builtin/environment/README.md +8 -25
- package/python/harness/builtin/prompts/conversation/core.md +6 -5
- package/python/harness/builtin/prompts/core/core.md +147 -203
- package/python/harness/builtin/prompts/core/pack.toml +0 -1
- package/python/harness/builtin/prompts/reflect/core.md +8 -32
- package/python/harness/builtin/prompts/reflect/pack.toml +2 -4
- package/python/harness/builtin/prompts/shared/agent-skills.md +5 -3
- package/python/harness/builtin/prompts/shared/agents.md +20 -10
- package/python/harness/builtin/prompts/shared/checklist.md +13 -17
- package/python/harness/builtin/prompts/shared/environments.md +20 -15
- package/python/harness/builtin/prompts/shared/learning-goal.md +2 -3
- package/python/harness/builtin/prompts/shared/learning.md +73 -23
- package/python/harness/builtin/prompts/shared/mcp.md +11 -6
- package/python/harness/builtin/prompts/shared/reflex-method.md +243 -0
- package/python/harness/builtin/prompts/shared/units.md +138 -0
- package/python/harness/builtin/prompts/shared/web.md +5 -6
- package/python/harness/builtin/skills/agents/__init__.py +18 -3
- package/python/harness/builtin/skills/agents/skill.toml +3 -3
- package/python/harness/builtin/skills/checklist/__init__.py +34 -32
- package/python/harness/builtin/skills/checklist/skill.toml +9 -9
- package/python/harness/builtin/skills/environments/__init__.py +9 -5
- package/python/harness/builtin/skills/environments/skill.toml +1 -1
- package/python/harness/builtin/skills/experience/skill.toml +1 -1
- package/python/harness/builtin/skills/learning/__init__.py +19 -5
- package/python/harness/builtin/skills/mcp/skill.toml +1 -1
- package/python/harness/builtin/skills/memory/__init__.py +4 -1
- package/python/harness/builtin/skills/memory/skill.toml +0 -5
- package/python/harness/builtin/skills/verify/skill.toml +1 -0
- package/python/harness/builtin/skills/web/__init__.py +4 -1
- package/python/harness/builtin/third_party/sources.toml +2 -40
- package/python/harness/cli.py +16 -25
- package/python/harness/config/__init__.py +2 -2
- package/python/harness/config/agent.py +59 -47
- package/python/harness/core/__init__.py +1 -1
- package/python/harness/core/codec.py +4 -4
- package/python/harness/core/contracts.py +1 -1
- package/python/harness/core/media.py +1 -1
- package/python/harness/core/ports.py +2 -2
- package/python/harness/core/procs.py +1 -1
- package/python/harness/core/remote.py +1 -1
- package/python/harness/core/worker.py +19 -13
- package/python/harness/embodiments.py +53 -44
- package/python/harness/extensions.py +22 -0
- package/python/harness/host/__init__.py +1 -1
- package/python/harness/host/http.py +6 -12
- package/python/harness/host/sessions.py +1 -1
- package/python/harness/host/tasks.py +15 -11
- package/python/harness/host/workspaces.py +36 -8
- package/python/harness/packages/__init__.py +5 -5
- package/python/harness/packages/environments.py +30 -18
- package/python/harness/packages/manager.py +1 -1
- package/python/harness/packages/manifest.py +6 -6
- package/python/harness/packages/provision.py +1 -1
- package/python/harness/packages/sources.py +1 -1
- package/python/harness/paths.py +1 -1
- package/python/harness/runtime/decision/loop.py +95 -5
- package/python/harness/runtime/decision/messages.py +128 -2
- package/python/harness/runtime/decision/model.py +4 -5
- package/python/harness/runtime/decision/prompts.py +20 -32
- package/python/harness/runtime/events.py +7 -5
- package/python/harness/runtime/execution/attached.py +3 -3
- package/python/harness/runtime/execution/entries.py +189 -8
- package/python/harness/runtime/execution/kernel.py +26 -1
- package/python/harness/runtime/execution/results.py +2 -3
- package/python/harness/runtime/execution/session.py +417 -32
- package/python/harness/runtime/execution/skills.py +63 -16
- package/python/harness/runtime/learning/active.py +7 -7
- package/python/harness/runtime/learning/learner.py +3 -2
- package/python/harness/runtime/learning/library.py +9 -4
- package/python/harness/runtime/learning/reflect.py +10 -9
- package/python/harness/runtime/reactive/rules.py +4 -4
- package/python/harness/runtime/reactive/tree.py +506 -25
- package/python/harness/runtime/safety/input.py +1 -1
- package/python/harness/runtime/safety/isolation.py +3 -3
- package/python/harness/runtime/safety/shield.py +4 -50
- package/python/harness/runtime/task/delegation.py +5 -5
- package/python/harness/runtime/task/environments.py +10 -0
- package/python/harness/runtime/task/run.py +222 -27
- package/python/harness/runtime/tick.py +24 -1
- package/python/harness/sdk/__init__.py +2 -5
- package/python/harness/services/registry.py +23 -19
- package/python/harness/settings.py +9 -9
- package/python/harness/builtin/environment/constraints.txt +0 -31
- package/python/harness/builtin/prompts/shared/world.md +0 -1
|
@@ -12,112 +12,108 @@ time with exactly one of:
|
|
|
12
12
|
|
|
13
13
|
<!-- if: look -->
|
|
14
14
|
When a program ends you see its output and what went wrong if anything did, as text.
|
|
15
|
-
A picture reaches you only when a program looks (look and watch below)
|
|
16
|
-
the state and the environment's calls give as text first, and look when that does not
|
|
17
|
-
tell, while a program runs as much as after it. Write one program for a coherent phase
|
|
18
|
-
with a clear completion condition.
|
|
15
|
+
A picture reaches you only when a program looks (look and watch below).
|
|
19
16
|
<!-- else -->
|
|
20
17
|
When a program ends you see its output, what went wrong if anything did and new
|
|
21
|
-
pictures.
|
|
18
|
+
pictures.
|
|
22
19
|
<!-- end -->
|
|
23
|
-
Let it observe, act, wait for a condition, and check the result as it goes. Handle
|
|
24
|
-
expected outcomes and bound any waits or retries. End the program when the phase is
|
|
25
|
-
complete, a choice needs your judgment, or an unexpected result makes it unsafe to
|
|
26
|
-
continue. A format error ran nothing: send one correct block. After a program error,
|
|
27
|
-
check the state before repeating anything because earlier steps may already have run.
|
|
28
20
|
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
is
|
|
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
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
output and result. One that is over within a moment gives you its result at once; a
|
|
92
|
-
longer one goes on, you are asked again at once with its name, and its result reaches
|
|
93
|
-
you when it ends. Meanwhile you are free: start another program, cancel one, or
|
|
94
|
-
wait. A wait ends when a unit you started ended, when a message or an event reached you,
|
|
95
|
-
or when its time is over, and you are told which. What a program starts (units, reflexes)
|
|
96
|
-
is yours: it outlives the program and the turn. After your answer it goes on,
|
|
97
|
-
and the end of a unit or an event starts your next turn; cancel what should not go on.
|
|
98
|
-
|
|
99
|
-
Whatever you are asked for, you are told in the same order: what your last reply came
|
|
100
|
-
to; then what reached you by itself since (the end of a unit, an event, a message), the
|
|
101
|
-
more urgent first; last, how things stand now: the state, the units that run, what
|
|
102
|
-
changed in the tree of reflexes. What cannot wait (an event, what the environment tells,
|
|
103
|
-
a unit that ended with an error) reaches you at once: a reply you were writing then is
|
|
104
|
-
set aside, what it held does not run, and you are asked again. The rest is told when you
|
|
105
|
-
are next asked.
|
|
21
|
+
How to work.
|
|
22
|
+
- Everything you do is for a result. It is done when the result is there, not when you
|
|
23
|
+
have carried out the action. Work in a loop: act, look at what the action did, compare
|
|
24
|
+
that with the result you wanted, and continue from the difference.
|
|
25
|
+
- When an action did not have its effect and what you have observed does not explain
|
|
26
|
+
why, look at what you have not looked at yet, right then, before you give a reason. Do
|
|
27
|
+
not repeat the same action to see whether it works this time, and do not carry on as
|
|
28
|
+
if the effect were there.
|
|
29
|
+
- Before you act, plan. Write what the task requires as things that must be true. For
|
|
30
|
+
each, write what will show that it is true, what is most likely to prevent it, and how
|
|
31
|
+
much is needed: calculate amounts and chances. Build your programs and the tree of
|
|
32
|
+
reflexes from this plan.
|
|
33
|
+
- Divide the plan into goals, in order, each with a result you can check. The task
|
|
34
|
+
itself stays the first goal on the list: every other goal is there for it.
|
|
35
|
+
- Before a program acts on the environment, it checks what the action relies on: the
|
|
36
|
+
thing it acts on, the way to it, what it uses. For each, write expect(text, check):
|
|
37
|
+
text says what you expect, check reads the environment now and returns True, or what
|
|
38
|
+
it found instead. When one does not hold, the program stops there and you are told
|
|
39
|
+
what was found. An action with no expect before it in the program is refused. What
|
|
40
|
+
holds for every action (the agent is there and able to act) is not one of them.
|
|
41
|
+
- Write an expect for everything the action relies on, not only for what you doubt.
|
|
42
|
+
Put one again before each part of a long program that relies on something new.
|
|
43
|
+
- An action changes more than the thing it acts on. Before a program acts, say what
|
|
44
|
+
else the action changes and what state you are in when it is done. You must be able
|
|
45
|
+
to go on from that state: write an expect for each thing that must be so for that.
|
|
46
|
+
- When every expect held and the result is not there, the program relied on something
|
|
47
|
+
it did not check: find it, and check it from then on. The next program that acts is
|
|
48
|
+
refused until it has an expect the failed one did not have.
|
|
49
|
+
- Keep one list of the goals: mark a goal when its result is there, and change the list
|
|
50
|
+
when what you find changes the plan.
|
|
51
|
+
- Where your plan depends on something you were given to act with, read the thing
|
|
52
|
+
itself, its documentation and its source: what it does, what it assumes, and what it
|
|
53
|
+
leaves to you.
|
|
54
|
+
- Decide by thinking whatever thinking can decide. Test the rest early, in the smallest
|
|
55
|
+
setup that shows it, where a failure costs little.
|
|
56
|
+
- Build each thing for the worst case it has to handle. Test it in the simplest case
|
|
57
|
+
that shows whether it does what it is for. If it does, it is done: do not test it
|
|
58
|
+
again because it could be better, and do not add protection beyond what it is for. If
|
|
59
|
+
it does not, fix it and test it again.
|
|
60
|
+
- Protect what cannot be undone or replaced.
|
|
61
|
+
- When something goes wrong, find the first point where what happened differed from what
|
|
62
|
+
you expected, fix what causes that kind of problem, and check for the same flaw
|
|
63
|
+
elsewhere. When the same kind of problem comes back, stop repeating: write down what
|
|
64
|
+
could cause it, check the most likely cause first, and change the approach.
|
|
65
|
+
- Time is what you spend. Know what each step took and what is left, and choose the
|
|
66
|
+
next step by that.
|
|
67
|
+
- A program that runs is yours to see through. Know how long it has to run. If you
|
|
68
|
+
wait for its end, you learn that it failed only then, and all that time is lost: find
|
|
69
|
+
out earlier. Come back to look well before it is due to end, have its report show the
|
|
70
|
+
numbers that tell how far it is (until(report=)), and have a node tell you when what
|
|
71
|
+
it relies on is gone. Each time you look, compare where it is with where it should be
|
|
72
|
+
by then, and change or end it when it is behind. Between the looks, prepare what comes
|
|
73
|
+
after it with what needs no acting on the environment: read the pages the next goal
|
|
74
|
+
needs, write and keep the code it needs, set the nodes for where the agent goes next,
|
|
75
|
+
bring the plan up to date. Send the program for the next goal too: it begins with
|
|
76
|
+
after(unit), then checks with expect, then acts.
|
|
77
|
+
<!-- if: learning -->
|
|
78
|
+
- Start from what your library holds: its skills, its tree, its notes. Fix an entry
|
|
79
|
+
when it falls short. Write new only what the library does not have.
|
|
80
|
+
<!-- end -->
|
|
81
|
+
- A format error ran nothing: send one correct block. After a program error, part of the
|
|
82
|
+
program has run: continue from the state as it is now.
|
|
106
83
|
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
84
|
+
Programs and units.
|
|
85
|
+
- A program states its result with until(condition): a function of the view that is true
|
|
86
|
+
when the work is done. A program that only reads says until(None). A program that says
|
|
87
|
+
neither is not started.
|
|
88
|
+
- A program that is over within a moment gives you its result at once. A longer one
|
|
89
|
+
keeps running as a unit: you are asked again at once, with its name, and you get its
|
|
90
|
+
result when it ends. Meanwhile you can start another program, cancel one, or wait.
|
|
91
|
+
- Every unit ends with a report: how it ended, whether its result is there (done: yes or
|
|
92
|
+
no), and what it returned. A unit that ended by itself is not thereby done. Read done.
|
|
93
|
+
- Everything you were told and everything you replied in this run is kept, in order, in
|
|
94
|
+
one file that a program can read. The summary that stands in for an earlier part of
|
|
95
|
+
the conversation gives its name.
|
|
96
|
+
- guide("units") has the rest: waits, what you are told and in what order, units of your
|
|
97
|
+
own, and who has the environment. Read it before you leave something running or start
|
|
98
|
+
a unit yourself.
|
|
114
99
|
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
you
|
|
119
|
-
|
|
120
|
-
|
|
100
|
+
The tree of reflexes.
|
|
101
|
+
- The world goes on by itself and does not wait for your replies. Reacting to what
|
|
102
|
+
happens to the agent is the job of the tree of reflexes: it runs all the time, without
|
|
103
|
+
you. Reaching a goal is your job, done by your programs. Do not put goals into the
|
|
104
|
+
tree.
|
|
105
|
+
- Plan the whole tree and set it before the agent starts work that depends on it. Every
|
|
106
|
+
node must have an action.
|
|
107
|
+
- Say what can happen to the agent during the whole task with situations(...), one line
|
|
108
|
+
for each, and name with each node the lines it answers (covers=). A program that acts
|
|
109
|
+
is refused while a line has nothing that answers it.
|
|
110
|
+
- Before the agent goes where it has not been, add what can happen to it there to
|
|
111
|
+
situations(...) and set those nodes first. Where the state shows that the agent is
|
|
112
|
+
somewhere the list was not made for, a program that acts is refused until you have.
|
|
113
|
+
- When a node acts at the wrong moment, change the node: its condition, its action, or
|
|
114
|
+
the node it is under.
|
|
115
|
+
- guide("tree") says how, and has every setting of a node. Read it before you set the
|
|
116
|
+
first node: set_reflex is refused until you have.
|
|
121
117
|
|
|
122
118
|
<!-- if: machine -->
|
|
123
119
|
Your programs run on the machine this conversation runs on, as its user. They read its
|
|
@@ -127,126 +123,74 @@ happens, the user is asked first, or it is refused, and then the call raises
|
|
|
127
123
|
PermissionError with the reason.
|
|
128
124
|
<!-- end -->
|
|
129
125
|
|
|
130
|
-
The calls every agent has
|
|
126
|
+
The calls every agent has. The guides have the details of those that name one.
|
|
131
127
|
|
|
132
|
-
-
|
|
133
|
-
|
|
134
|
-
|
|
128
|
+
- guide(name): ask for a page of instructions: "tree", "units", or a page a section below
|
|
129
|
+
names. The page is not returned to your program: it is given to you, whole, with your
|
|
130
|
+
next message, and you have read it from then on. The call returns one line that says so.
|
|
131
|
+
One message carries pages up to 100,000 characters: a page asked for beyond that is not
|
|
132
|
+
given, the line says so, and you ask for it again in a later program. A page you have
|
|
133
|
+
read is given to you again after a summary of the conversation. A call that waits for a
|
|
134
|
+
page is refused until you have read the page: the refusal gives you the page with your
|
|
135
|
+
next message, and you make the call again in a later program. reflex_method() is
|
|
136
|
+
guide("tree").
|
|
137
|
+
- until(condition, report=None, interrupted="tell"), until(None): what this program is
|
|
138
|
+
for, what it says of itself when you are told of it, and what happens when a reflex
|
|
139
|
+
takes the environment from it. guide("units").
|
|
140
|
+
- expect(text, check): what this program relies on, checked now. check is a function
|
|
141
|
+
without arguments that reads the environment and returns True, or what it found
|
|
142
|
+
instead. The end of the program lists each one with what its check showed.
|
|
143
|
+
- after(unit): wait until the unit of that name has ended, however it ended. Returns
|
|
144
|
+
{"ended", "done"}. A program sent while another still runs begins with it.
|
|
145
|
+
- get_observation(): what the world shows now (its pictures and its state); get_state():
|
|
146
|
+
the state alone; show(image): put a picture (a crop, a plot) with this program's
|
|
147
|
+
result.
|
|
135
148
|
<!-- if: look -->
|
|
136
|
-
- look(camera=None, region=None, keep=None, pin=None): put a view with this
|
|
137
|
-
result, so acting and looking are one program: all the views, one by
|
|
149
|
+
- look(camera=None, region=None, keep=None, pin=None, **settings): put a view with this
|
|
150
|
+
program's result, so acting and looking are one program: all the views, one by
|
|
138
151
|
name, or the part region=(x, y, width, height). A view stays for your next reply only;
|
|
139
152
|
keep=N keeps the views of your last N programs in sight, pin="name" keeps this one until
|
|
140
|
-
unpin("name").
|
|
153
|
+
unpin("name"). Any other setting is the environment's (which time, how many frames,
|
|
154
|
+
where its page names them) and is passed on as you give it. What look returns is a
|
|
155
|
+
picture you can put into a report (until(report=), set_reflex(report=)).
|
|
141
156
|
- watch(cameras=None, keep=None): from now on the views come with every program's result
|
|
142
157
|
until unwatch().
|
|
143
158
|
<!-- end -->
|
|
144
159
|
<!-- if: entries -->
|
|
145
|
-
- spawn(fn, name=None, priority=None, restart=False, until=None)
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
.send(message) gives it a message that receive(timeout=None) reads inside fn, .status.
|
|
149
|
-
entries(): the handles of the units that run, your programs among them, each with its
|
|
150
|
-
.id (the name you are told).
|
|
151
|
-
output_of(unit, chars=2000): what a unit (its id or its handle) has printed so far, the
|
|
152
|
-
last chars characters (at most 30000); its result still has all of it when it ends.
|
|
153
|
-
What you are told has a limit, and says so where it left something out: what a unit
|
|
154
|
-
printed or returned is told whole up to 30000 characters; more is saved to a file, and
|
|
155
|
-
you are told the file, which a program can read, and its first 2000 characters. Of a
|
|
156
|
-
unit that failed you are told the first and last 5000 characters.
|
|
160
|
+
- spawn(fn, name=None, priority=None, restart=False, until=None), with its handle's
|
|
161
|
+
.wait(timeout=None), .cancel(), .send(message), .status and receive(timeout=None)
|
|
162
|
+
inside fn; entries(); output_of(unit, chars=2000): units of your own. guide("units").
|
|
157
163
|
<!-- if: channels -->
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
unclaim(*channels) lets them go, channels() says who has each. Reaching for a channel
|
|
161
|
-
another unit has is a CHANNEL_CONFLICT event.
|
|
164
|
+
- claim(*channels), unclaim(*channels), channels(), spawn(..., claims=[...]): units that
|
|
165
|
+
act at the same time on the environment's channels (CHANNELS). guide("units").
|
|
162
166
|
<!-- end -->
|
|
163
167
|
<!-- end -->
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
Among the nodes at one place the earlier takes the environment from the later, and gives
|
|
169
|
-
it back when it is done. What several nodes read is a sense; what several do is a
|
|
170
|
-
function they call.
|
|
171
|
-
- set_reflex(name, when, do=None, under=None, priority=0, every=None, again_seconds=0):
|
|
172
|
-
put the node `name` into the tree, in place of a node of that name.
|
|
173
|
-
when: a function of the view: the node has its turn while it holds. It is judged
|
|
174
|
-
without you, and the node takes the environment as soon as it holds. Or the name of an
|
|
175
|
-
event: the node answers that event when it happens, and you are not told of it then.
|
|
176
|
-
do: a program (a function): started as a unit when the node's turn comes; what it is
|
|
177
|
-
for is that the node's condition no longer holds. It begins again while the turn lasts,
|
|
178
|
-
not before again_seconds after it ended; a program that answers an event gets the event
|
|
179
|
-
when it takes an argument. Or the name of an event: you are told it, once each time
|
|
180
|
-
its turn comes, which is when its condition holds and no node under it or before it at
|
|
181
|
-
its place is answering. Or "stop": what runs is ended.
|
|
182
|
-
Or nothing: only the nodes under it answer.
|
|
183
|
-
under: the node `name` is a narrower situation within that one. A node may be put
|
|
184
|
-
under any node whose `when` is a condition, whatever that node does itself and without
|
|
185
|
-
setting it again.
|
|
186
|
-
priority (a whole number, 0 or more): the node's own, wherever it is in the tree. Of
|
|
187
|
-
two nodes whose turn it is the higher has the environment, among equals the earlier in
|
|
188
|
-
the tree; and it is the number a program's at_priority(n) is compared with. A node's
|
|
189
|
-
program takes the environment from your programs.
|
|
190
|
-
every: the seconds between judgements of its condition; without it the condition is
|
|
191
|
-
judged when the state or the facts change.
|
|
192
|
-
A condition is read, not computed: the conditions judged in one moment share a few
|
|
193
|
-
milliseconds between them, and may not open files, use the network, sleep or start
|
|
194
|
-
anything. One the moment had no time for is judged in the next. One that is slower
|
|
195
|
-
than that time after time, or that raises, is a fault: its node is removed with the
|
|
196
|
-
nodes under it and you are told (the event REACTIVE_FAULT).
|
|
197
|
-
You are not told when a node's program has done its work. When it ends and its
|
|
198
|
-
situation is not over, or it fails, a later node at its place whose condition holds has
|
|
199
|
-
the environment; when none has, you are told with the program's report (the event
|
|
200
|
-
REFLEX_FAILED), once until the node has done its work again.
|
|
201
|
-
- reflexes(name=None): the nodes at the top of the tree, or the nodes under the node
|
|
202
|
-
name (the node itself where it has none under it), at most 50 at a time: each with
|
|
203
|
-
whether its condition holds, whether its program runs, how often it began, the report
|
|
204
|
-
of its last run and the names of the nodes under it. With every turn you are told how
|
|
205
|
-
many nodes act in the tree and, of those that changed since you were last told, how
|
|
206
|
-
often each one's program began, did its work and did not (at most 10; reflexes() has
|
|
207
|
-
the rest). drop_reflex(names=None): remove nodes with the nodes under them (None: all).
|
|
168
|
+
- set_reflex(name, when, do, under=None, priority=0, every=None, again_seconds=0,
|
|
169
|
+
ends=False, tell=None, tell_failed="now", about=None, report=None, test=None,
|
|
170
|
+
covers=None), reflexes(name=None), drop_reflex(names=None), situations(*lines): the
|
|
171
|
+
tree of reflexes and the list of what it has to answer. guide("tree").
|
|
208
172
|
- facts.set(name, value), facts.get(name, default=None), facts.drop(name): what the run
|
|
209
|
-
knows, shared by your programs and reflexes (view["facts"]). Keep progress there, so
|
|
210
|
-
what you start again goes on from what was done.
|
|
173
|
+
knows, shared by your programs and reflexes (view["facts"]). Keep progress there, so
|
|
174
|
+
that what you start again goes on from what was done.
|
|
211
175
|
<!-- if: senses -->
|
|
212
|
-
- sense(name, code): have the environment compute a value
|
|
213
|
-
|
|
214
|
-
programs. `code` is in the environment's own language and reads the environment
|
|
215
|
-
directly (the environment's own page says what the code has). It returns {"value": as
|
|
216
|
-
computed now, "error"}. senses(): those defined, with their code and values;
|
|
217
|
-
drop_sense(name).
|
|
176
|
+
- sense(name, code), senses(), drop_sense(name): have the environment compute a value
|
|
177
|
+
itself each time it reports its state. guide("tree").
|
|
218
178
|
<!-- end -->
|
|
219
|
-
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
179
|
+
- verify(claim, cameras=None): ask the success verifier whether the claim holds in what the
|
|
180
|
+
environment shows now. Returns (holds, answer); holds is None where there is no verifier.
|
|
181
|
+
- run_controller(fn, until=None, max_seconds=None): apply the command returned by
|
|
182
|
+
fn(view) for each step. Return None to end it. A reflex or until(view) can end the
|
|
183
|
+
execution.
|
|
184
|
+
- at_priority(n): `with at_priority(n):` around one action that must not be broken off.
|
|
185
|
+
Every node below n waits for that time. It is for rare cases. Before you use it, ask
|
|
186
|
+
whether the tree is wrong: when a node breaks off your work, look at that node first
|
|
187
|
+
and change it. guide("units").
|
|
188
|
+
A reflex's program takes the environment from your programs.
|
|
223
189
|
<!-- if: pauses -->
|
|
224
|
-
|
|
225
|
-
ended: its program does not end, and you are not asked.
|
|
190
|
+
Your call is paused where it is and goes on by itself when the reflex's program has ended.
|
|
226
191
|
<!-- else -->
|
|
227
|
-
|
|
228
|
-
at once: which reflex took the environment, from which program, and the state. You decide
|
|
229
|
-
what goes on: the same again, or something else. Only a unit started with restart=True
|
|
230
|
-
has its call started again by itself then (its result counts it: .restarts).
|
|
192
|
+
Your call ends there with the event PREEMPTED, and you are told at once.
|
|
231
193
|
<!-- end -->
|
|
232
|
-
What you start meanwhile waits for the higher unit to end. Units of equal priority take
|
|
233
|
-
turns.
|
|
234
|
-
Your programs have priority 0, so every reflex takes the environment from them. An
|
|
235
|
-
action of a program that must not be broken off takes a place among the reflexes for as
|
|
236
|
-
long as it lasts: `with at_priority(n):` around that action, and no longer. During the
|
|
237
|
-
block a reflex whose own priority is n or more still takes the environment from the
|
|
238
|
-
program, which goes on as said above; a reflex below n waits: it is judged again when the
|
|
239
|
-
block ends, and you are told once that it was held back (the event HELD_BACK). The place is the action's, not the program's or a stage's:
|
|
240
|
-
while it is held, nothing below it answers what happens to the agent, so a program that
|
|
241
|
-
holds one for its whole length has taken the tree's work on itself and must do all of it.
|
|
242
|
-
Code that runs for long in the environment itself asks for a place the same way, where
|
|
243
|
-
the environment's page says how.
|
|
244
|
-
Conditions and controllers read the supplied view. Keep them fast and free of file,
|
|
245
|
-
network, process and input operations. Beside the state as it is, the view holds what a
|
|
246
|
-
state alone does not show: view["was"][key], what that part of the state was before it
|
|
247
|
-
last changed; view["unchanged"][key], for how many seconds it has not changed (the senses
|
|
248
|
-
under ["sensed"] in both); and view["units"], the units that run, each {"name", "kind",
|
|
249
|
-
"reflex", "priority", "seconds"}.
|
|
250
194
|
<!-- if: memory -->
|
|
251
195
|
<!-- if: legacy_memory -->
|
|
252
196
|
- recall(query): what earlier runs kept about a situation like this one.
|
|
@@ -3,7 +3,6 @@
|
|
|
3
3
|
# starts with it ({ pack = "../core" }) and adds its own sections.
|
|
4
4
|
sections = [
|
|
5
5
|
{ file = "core.md" },
|
|
6
|
-
{ file = "../shared/world.md", skills = ["world"] },
|
|
7
6
|
{ file = "../shared/web.md", skills = ["web"] },
|
|
8
7
|
{ file = "../shared/learning.md", skills = ["learning"] },
|
|
9
8
|
]
|
|
@@ -1,36 +1,12 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
You read one finished development episode and the current library of lessons and helper functions, and propose at most ONE addition that would help future episodes on any task:
|
|
9
|
-
<!-- else -->
|
|
10
|
-
You read observed task results and the current library of notes and helper functions, and propose at most ONE addition that would help future episodes on any task:
|
|
11
|
-
<!-- end -->
|
|
12
|
-
<!-- if: robot -->
|
|
13
|
-
a short note (a general lesson, not about this layout's coordinates),
|
|
14
|
-
<!-- else -->
|
|
15
|
-
a short note (a general lesson, not about what holds in this one run only),
|
|
16
|
-
<!-- end -->
|
|
17
|
-
a memory entry (a specific situation and what worked or failed, which the agent can look up with recall(query)), a helper skill (a Python function using the API names the agent uses), or
|
|
18
|
-
<!-- if: robot -->
|
|
19
|
-
a reactive helper (a pure, fast predicate or controller of obs).
|
|
20
|
-
<!-- else -->
|
|
21
|
-
a reactive helper (a pure, fast guard predicate of the view).
|
|
22
|
-
<!-- end -->
|
|
1
|
+
You read what an agent did in one finished episode, and its library. Propose at most one addition to the library that would help later episodes on any task.
|
|
2
|
+
The agent acts in its environment by writing Python programs that call the functions of its skills.
|
|
3
|
+
What you can propose:
|
|
4
|
+
- A note: a short general lesson. Not something that holds in this one episode only.
|
|
5
|
+
- A memory entry: one specific situation and what worked or failed in it. The agent looks it up with recall(query).
|
|
6
|
+
- A skill: one public Python function with a docstring, written with the calls the agent uses. In the docstring, cite the outcomes in the episode that support it. After the skill, write <test>a Python call of the function and the result that shows it worked</test>. The host runs that test before the skill is used.
|
|
7
|
+
Propose a skill when the episode shows the same judgment working more than once.
|
|
23
8
|
<!-- if: experience -->
|
|
24
9
|
Do not propose tallies of how often a skill worked or where something was found: practice counts those by itself in the library's experience, which skills read as hints.
|
|
25
10
|
<!-- end -->
|
|
26
|
-
Reply with exactly one of <note name="snake_case">...</note>, <memory name="snake_case">...</memory>, <skill name="snake_case">...</skill>, <
|
|
27
|
-
<!-- if: robot -->
|
|
28
|
-
Code must define one public function with a one-line docstring.
|
|
29
|
-
<!-- else -->
|
|
30
|
-
When the observations show a judgment repeatedly worked, consider turning it into a skill.
|
|
31
|
-
When a frequently useful part of a skill can decide what to do using only the current view, consider a reflex (set_reflex).
|
|
32
|
-
Cite the outcomes that support the proposal in its docstring. Code defines one public function with a docstring.
|
|
33
|
-
For code, follow the entry with <test>Python invocation and observable success condition</test>.
|
|
34
|
-
The host independently checks the behavior. Use <none/> when the evidence does not support an addition.
|
|
35
|
-
<!-- end -->
|
|
11
|
+
Reply with exactly one of <note name="snake_case">...</note>, <memory name="snake_case">...</memory>, <skill name="snake_case">...</skill>, or <none/>. Reply <none/> when the episode does not support an addition.
|
|
36
12
|
A note is at most {note_max_chars} characters, a memory entry at most {memory_max_chars}; a longer one is discarded.
|
|
@@ -1,8 +1,6 @@
|
|
|
1
1
|
# The reflection request (runtime/learning/reflect.py: between episodes, the model proposes one
|
|
2
|
-
# library entry)
|
|
3
|
-
#
|
|
4
|
-
# the skills the run enabled. What belongs to one environment is not said here: its
|
|
5
|
-
# package says it.
|
|
2
|
+
# library entry). It is the same whatever the agent acts in: what belongs to one
|
|
3
|
+
# environment is not said here, its package says it.
|
|
6
4
|
sections = [
|
|
7
5
|
{ file = "core.md" },
|
|
8
6
|
]
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
|
|
2
|
-
Skills the user installed
|
|
3
|
-
one before a task it covers:
|
|
2
|
+
Skills the user installed are instructions for kinds of tasks. They are listed at the end.
|
|
4
3
|
|
|
5
|
-
read_skill(name, file="SKILL.md")
|
|
4
|
+
read_skill(name, file="SKILL.md")
|
|
5
|
+
the skill's instructions, or another file of it
|
|
6
|
+
|
|
7
|
+
- Read a skill before a task it covers.
|
|
@@ -1,14 +1,24 @@
|
|
|
1
1
|
|
|
2
|
-
Sub-agents work at the same time as you, on budgets taken from yours
|
|
2
|
+
Sub-agents work at the same time as you, on budgets taken from yours.
|
|
3
3
|
|
|
4
|
-
delegate(task, workspace="new", budget=None, model=None, agent=None)
|
|
5
|
-
id. task: what to do and
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
"
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
"
|
|
4
|
+
delegate(task, workspace="new", budget=None, model=None, agent=None)
|
|
5
|
+
start one; returns its id. task: what to do and
|
|
6
|
+
report, on its own (it does not see your
|
|
7
|
+
conversation). workspace: "new" (your kind) or an
|
|
8
|
+
available workspace kind. budget: {"calls", "cost",
|
|
9
|
+
"seconds"}. agent: an installed agent adapter; omit
|
|
10
|
+
it to use this Harness.
|
|
11
|
+
wait_agents(ids=None, timeout=None)
|
|
12
|
+
wait until each ends or asks: {id: {"status",
|
|
13
|
+
"result", "question", "model_calls", "cost_usd",
|
|
14
|
+
"seconds", "directory", "files"}}
|
|
13
15
|
send_agent(id, text) answer one, or give it more to do
|
|
16
|
+
review(code, purpose, budget=None)
|
|
17
|
+
have code you wrote read by a sub-agent that has not
|
|
18
|
+
seen your conversation: it gets the code and what it
|
|
19
|
+
is for, and reports what in it would fail, do the
|
|
20
|
+
wrong thing or waste its time. Returns its id;
|
|
21
|
+
wait_agents gives the report.
|
|
14
22
|
cancel_agent(id) stop one; returns its report
|
|
23
|
+
|
|
24
|
+
- Use review for code that is kept and relied on, not for every program.
|
|
@@ -1,21 +1,17 @@
|
|
|
1
1
|
|
|
2
|
-
The user watches
|
|
2
|
+
You keep a list of the task's steps. The user watches it beside the conversation, and
|
|
3
|
+
you are shown it again when you have not touched it for a while.
|
|
3
4
|
|
|
4
|
-
plan(*steps)
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
cheap flights"); call it again to change it
|
|
5
|
+
plan(*steps) the task's steps in order, each short, in the user's
|
|
6
|
+
language; call it again when the steps change,
|
|
7
|
+
without the ones that are no longer needed
|
|
8
8
|
step_done(number) check off step `number` (1 for the first)
|
|
9
9
|
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
</python>
|
|
19
|
-
|
|
20
|
-
Do not write <plan>...</plan> or invoke a native tool named "plan". Deliver the requested
|
|
21
|
-
description before marking its step done; a plan is not the final answer.
|
|
10
|
+
- Keep a list for a task of three or more steps, and when you are given several things
|
|
11
|
+
to do. A single simple step needs none.
|
|
12
|
+
- The first step not checked off is the one you are on: there is always exactly one.
|
|
13
|
+
- Check a step off in the program that does it, as soon as it is done, not several at
|
|
14
|
+
once later.
|
|
15
|
+
- A step is done only when it is fully accomplished. One that met an error, is done in
|
|
16
|
+
part, or lacks something it needs stays where it is. When you are blocked, add a step
|
|
17
|
+
that says what has to be resolved first.
|