Fractal Accelerator - Class 2 notes

The main idea

An agent can only work with the information it can see. When its output feels like a slot machine—sometimes brilliant, sometimes unusable—the first thing to inspect is its context, not the agent’s personality or intelligence.

When an agent’s output feels like a slot machine, curate its context.

Context fails in two ways:

• Missing information: the agent does not know your goals, preferences, constraints, files, or workflow.
• Too much noise: the context contains stale instructions, irrelevant material, or contradictions that make the task ambiguous.

When an agent goes wrong, ask:

1. What information does it need that it does not have?
2. What information might be confusing or distracting it?

Those questions turn a vague feeling that “the AI is bad” into a concrete design problem.

1. Context is the agent’s working material

In practical terms, context is the text available to the model on a turn: system and project instructions, your messages, files and sources, previous replies, and the results of actions taken with tools. If information never enters that context, the agent cannot use it.

A new conversation should be treated as a fresh start. The agent may know general facts about the world, but it does not automatically know your personal goals, the structure of your files, the decision you made yesterday, or how you like work done. Durable instructions and reference files are how you make that knowledge available again.

The context window is also bounded. An ever-growing conversation eventually contains old decisions, abandoned approaches, and conflicting instructions. Start a new conversation for a new piece of work, then provide the small amount of context that matters for that work.

2. Use a working loop instead of one-shot prompting

Working with an agent is an iterative design process:

Goal → Generate → Inspect → Clarify → Try again

• Goal: state the outcome, audience, constraints, and what “good” looks like.
• Generate: ask the agent to propose, draft, research, or build.
• Inspect: compare the result with the goal. Check evidence, omissions, tone, and behavior—not just whether the output looks polished.
• Clarify: identify the missing requirement, wrong assumption, or confusing instruction.
• Try again: give the new information and repeat until the result works.

The first output is evidence about the quality of the context. It is not necessarily the answer.

Agents are generative systems: they are usually better at producing more of a desired pattern than at obeying a long list of prohibitions. Give examples of the voice, structure, level of detail, or behavior you want. Say what to do, not only what to avoid. Your judgment—choosing a direction, rejecting weak options, and refining the result—is part of the system.

3. Four layers of an agent system

It helps to separate four layers that are often collapsed into “the AI”:

1. Language model: predicts what should come next based on the context it receives. It can produce plans, programs, and explanations, but it cannot respond to information it was not given.
2. Context window: the bounded block of text passed to the model on each turn.
3. Agent: the model-plus-loop that chooses actions, uses tools, observes results, and continues.
4. Harness: the surrounding product—such as Zo, Codex, or Claude Code—that determines the available tools, permissions, files, interface, and context management.

The model predicts. The context steers. The agent acts. The harness shapes the environment.

This gives you a better debugging map:

• A fabricated claim is often a grounding or verification problem: provide authoritative sources and ask for receipts such as citations, file paths, tool output, or tests.
• A response that ignores your preferences is often a context problem: make the preference explicit and durable.
• A poor plan or wrong tool choice is an agent-loop problem: clarify the goal, ask for a plan, or require inspection before action.
• An inability to access a file, account, or setting is a harness problem: check permissions, connections, and product configuration.

“AI slop” is the result of accepting low-judgment output simply because it was produced quickly. Prevent it with direction, examples, selection among alternatives, and revision.

4. Give the agent durable memory

Repeating the same explanation in every conversation is a sign that the explanation belongs in a file. Memory is not magic; for a computer-based agent, memory is organized context in the file system.

Long-term memory: AGENTS.md

Use AGENTS.md for facts and rules the agent should remember across tasks:

• who you are and what you are trying to accomplish;
• how you use the computer and where important things live;
• preferences about writing, design, tools, and communication;
• project goals, current state, sources, and verification requirements;
• mistakes or misunderstandings you keep having to correct.

Instructions can be layered by folder:

Computer/
├── AGENTS.md              ← personal context and durable preferences
└── Projects/
    └── current-project/
        ├── AGENTS.md      ← goal, state, sources, and local rules
        ├── notes/
        ├── sources/
        └── work/

Keep the file focused. It can point to supporting material rather than containing every detail itself. Add context in response to real failures; a giant pre-built structure can overfit the agent to assumptions you have not tested.

Procedural memory: skills

Use a skill when the thing to remember is how to perform a recurring kind of work. A skill is a folder containing a SKILL.md with instructions, plus optional references, assets, or scripts:

skills/
└── my-skill/
    ├── SKILL.md           ← when and how to do the task
    ├── references/        ← useful knowledge
    ├── assets/            ← templates and examples
    └── scripts/           ← optional supporting tools

AGENTS.md says “know this about me or this project.” A skill says “when this type of task appears, follow this process.” Examples include writing in your voice, building a website with your design rules, or processing a recurring kind of email.

5. Keep one canonical data home

Agents become much more useful when they can reliably find the same source material across your local and cloud computers. The general pattern is:

1. Keep one canonical Personal OS folder or repository.
2. Organize projects and reference material inside it.
3. Use a deliberate synchronization mechanism so copies stay consistent.
4. Put instructions near the data they describe, with AGENTS.md files at the appropriate levels.

This is the same problem organizations solve with a monorepo and version control: one coherent place to look, plus history and synchronization across machines. A cloud computer is useful for always-on access and shared or larger workloads; a local computer is private, fast, works offline, and has fewer moving parts. The important thing is that both surfaces point to an understandable source of truth.

6. Exercises and practices from Class 2

The exercises turned agent use into a source of durable improvements. The full Where do you need better context? exercise is available to run separately. The exercises were designed to surface problems, make useful work legible, and convert recurring friction into better context or reusable procedures.

Exercise: retrospective — improve a repeating process

A retrospective reviews a process that will happen again. Agent work is a good candidate because even a small improvement compounds across hundreds of future tasks. The retrospective step in the Agent Design Game is a reusable version of this practice.

During class, the retrospective took place in a shared written workspace. Participants:

• reflected on the previous week’s work and the parts that felt difficult or effective;
• read other people’s reflections to find problems they had already solved;
• added short replies with useful approaches, tips, or resources.

Because the point was shared inspection, each contribution began with the writer’s name or initials. People wrote freely, then replied directly beneath one another’s entries instead of using the document’s separate comment feature. A useful output was a list of recurring blockers and promising solutions that could become reference material, office-hours topics, or changes to the course and each person’s Personal OS.

Exercise: where do you need better context? (15 minutes)

Use the complete exercise page to run this activity. It uses emotional reactions and recurring mistakes as diagnostic signals. Answer the following questions using concrete moments from recent agent work:

1. When do you feel bad while using your agent—angry, frustrated, distrustful, overwhelmed, confused, or bored?
2. When do you feel good—surprised, delighted, relaxed, safe, curious, engaged, proud, or focused?
3. What common mistakes does your agent keep making?
4. What do you wish your agent always knew about your work, yourself, or the context of what you are doing?

The point is not to publish personal answers. It is to connect each feeling or repeated mistake to a context diagnosis: missing information, noisy information, an unclear goal, or a tool and permission problem. The output is a shortlist of context improvements to make permanent.

Exercise: what should your agent remember?

Use the What Should Your Agent Remember? prompt in a fresh agent conversation and provide enough context about the week’s work for the agent to identify durable facts and preferences. Ask it to separate information that belongs in long-term memory from information that is only relevant to the current task. The result is a candidate set of entries for AGENTS.md: goals, working preferences, where things live, recurring corrections, and project rules.

Exercise: what should your agent learn how to do?

Use the What Should Your Agent Learn How to Do? prompt in another fresh conversation, carrying over the relevant work context, and ask the agent to identify actions you perform repeatedly: writing, creating websites, using a set of applications, or moving information between systems. The result is a shortlist of candidate skills—reusable procedures that can be written into SKILL.md files. Before building one from scratch, look for an existing public skill that already covers the task and adapt it to your own workflow when appropriate.

7. Configure the harness safely

Agent products may combine a flat subscription with metered pay-per-use credits. Check that the product is using the subscription you intended, understand where usage is displayed, and monitor it while you are learning the system. Do not assume that a tool is free simply because it looks like a consumer application.

If an agent has access to payment details, consider a payment method with an explicit spending limit. A setting that causes unexpected charges is a harness problem, not evidence that the model itself is malfunctioning.

The same distinction applies to interfaces: a browser chat is a web application and normally cannot inspect or modify files on your computer. A computer-based agent such as Zo, Codex, or Claude Code can do that only through the tools and permissions provided by its harness.

Practical catch-up checklist

To apply the ideas from this class:

• Identify one recent agent failure and diagnose it as missing context, noisy context, an agent-loop issue, or a harness issue.
• Add one durable fact or preference to the appropriate AGENTS.md.
• Turn one repeated procedure into a first skill.
• Use the working loop—goal, generate, inspect, clarify, try again—on your next task.
• Confirm that your agent product is using the intended pricing and permissions.
• Run the two memory-discovery prompts and keep only the changes that solve real recurring problems.

Compact glossary