37,617 results · Most relevant
Will Lyon recommends distilling a workspace- or project-scoped context graph into a skill grounded in actual observed data rather than just a markdown file, with deterministic, well-understood procedural steps in the graph.
Will Lyon recommends a knowledge graph with strong types and relationships describing how entities are related, and stresses that the entity resolution phase — ensuring a canonical representation of a thing, like knowing Dr. Nguyen is a provider with a name and role — is one of the most important parts of building the graph.
Matt Gibiec describes a workflow: start by observing your environment to build context and dependency mapping; provide production data and details locally to developers as they test; when a service deviates from normal (slower or throwing new errors), inform the developers' agents in the IDE; integrate the tooling in the code repository so it has context of what changed, and overlay change data with issue data to attribute issues to pushed changes or unsuccessful merges; when issues are detected, suggest a fix that uses the context of your environment, application, and monitored agents — not just a fix for the particular breaking issue; and drive the entire SDLC by providing the fix while giving you control at the end to decide whether to push the feature or fix out.
Fedus describes how Periodic Labs builds RL environments from its own data: timestamp the state of experimental evidence at each date so you can reconstruct what was known; build environments asking, given this body of evidence and the choices, what was the next choice the scientist made or the outcome of that experiment; for phase-identification environments, reward correct identification of phases actually present and penalize spurious phases or phases with no chemical plausibility; and maintain lineage of the whole experimental process, which enables constructing RL environments that aren't plausible elsewhere.
Matt Owens recommends putting yourself in a fast-growing environment shortly after school — a small startup where you can hire, collaborate, and learn from designers, developers, and business people all figuring it out together. He describes working 14 hours a day at Method 5, a startup that grew from 7 to 45 people in about a year and a half, calling it a 'pressure cooker' that was a blessing after grad school.
The described memory-learning system works as a loop: when an agent runs, its context is loaded from a context hub (instructions, skills, markdown files, policies, rules). When the agent is invoked, a trace is produced showing failed tool calls, user corrections, and deviations such as tone straying from the desired tone. An engine then looks for patterns in those traces and identifies where static skill markdown files in the context hub need to be changed or promoted, and makes that change. After the memory update process runs, the next time the agent runs its tone visibly changes in interactions with users.
described as the speaker's system; behavior change observed by the speaker, not benchmarked
An important consideration in self-updating agents (like OpenClaw and Hermes) is deciding what to make self-updateable versus what needs human review. Procedural memory — instructions, policies, and tone guidelines — probably drives about 75% of an agent's behavior, so changes to it should be surfaced to a human before being committed to the agent's hot reload path.
the 75% figure is the speaker's own estimate for his agent, not a measured benchmark
When tools return large data (logs, database results): externalize by moving big data to persistent storage with a memory pointer, select by retrieving only what is relevant, and compress by summarizing/compacting information.
Build a two-tool pattern: one tool fetches the large data (e.g., application logs) and saves it to storage, returning a memory pointer ID; a second tool retrieves the data by ID only when needed. Don't put large tool outputs into the context window on every invocation. When the agent actually needs the raw data, it presents the stored ID to retrieve it.
Dr. Morin advises that on acceleration day, you focus only on the acceleration — everything afterwards is not important. When coaches cue and emphasize everything every time in sprinting, there is no way to get quality over the entire spectrum — this is the main problem of beginning coaches. He structures one weekly session focused on acceleration and two sessions focused on high-speed running, with the second high-speed session being a hamstring prevention session rather than a max-velocity session. For acceleration work, he uses about the same metrics as high-speed work (100-150 meters of exposure), noting it's a principle, not a recipe.
Consequential creator advice requires independent verification before Today can promote it.
For athletes who must stay in bent positions (like point guards), you would never tell them to drive less horizontally because it is dangerous for the hamstrings; instead, teach them to be much stronger with their trunk and hamstrings in exercises that stimulate highly bent positions.
Dr. Morin advises that when an athlete shows good top speed, strength, and broad jump but weak acceleration, the first step is to assess acceleration objectively with metrics — maximum force output and maximum propulsive power output on the ground. You can also bring kinematic analysis including contact time to diagnose acceleration weaknesses such as trunk collapse or overly vertical push. He stresses combining quantitative numbers with qualitative movement assessment — how does he move? He also notes that changing the trunk angle during acceleration likely addresses braking issues in the first three to seven steps (per the host's example with a running back), and that an athlete already elite at high jump will very likely not improve acceleration by jumping higher.
Dr. Morin recommends that for athletes who must stay in bent positions for their sport (like running backs and basketball point guards), rather than changing their running technique, you strengthen the trunk and hamstrings in highly bent positions. He advises using very intense trunk flexion exercises, choosing exercises that involve both trunk flexion and huge hip flexion, and using unilateral exercises as much as possible to replicate the lunge and sprint movement. He cites the drop and catch RDL as an example of a very intense trunk and hip flexion exercise, and notes resisted sprinting is useful because it forces the athlete to be more bent forward with higher hip flexion, strengthening the posterior chain with kinematics close to future actions. The same bent-position strengthening is
The first step to improving acceleration is to assess it objectively with metrics: maximum force output, maximum power output, and propulsive power output on the ground.
Matt Brockman recommends giving sandboxes a really long time to live so they can run as long as the task needs (e.g. a one-hour command timeout), but once the task finishes, set a very short lifetime (about one minute) so the sandbox shuts itself down and frees resources for another sandbox.
A common sandbox pattern is to install base dependencies (like GitHub Actions caching), then fork the sandbox and build on top of the replica. When starting with a vanilla sandbox, keep adding to it and fork it so others get a replica; eventually bring it all together. This also enables forking a data science workload into multiple sandboxes to run experiments in parallel, and handing off in-progress work to others by sharing a sandbox template.
Matt Brockman's core lifecycle policy: give sandboxes a really long time to live while a task runs (e.g., one-hour command timeout), but once the sandbox finishes its task, give it a very short timeout (one minute) so it shuts itself down and frees resources for someone else's sandbox. This applies to unpredictable workloads like reading large files or video processing. A participant also confirmed you can pause or shut down a finished sandbox to resume it later if the user returns.
Matt Brockman recommends spinning up a new sandbox specifically for a project so you can break it without breaking your initial stuff; if something breaks, just restart the sandbox — the reload button resets it to its original snapshot state.
At RunLayer, agents do the real work; similar agent runs are grouped together and a skill is distilled from them — when a run succeeds and contains something interesting (multiple tool calls), they take the trace and ask a frontier LLM to distill a skill from it. Distilled skills pass through a series of checks, including whether they contain prompt injection or PII, before being accepted. Once a skill passes its checks, it lands in the skill library, and an MCP gateway serves approved skills to each and every client and agent within the company. Distilled skills are included in all future agent runs so each run benefits from prior discoveries.
When rolling out AI strategy across a company, govern skill distribution from one centralized place (the MCP server) rather than scattered local installs, giving one place to manage what knowledge is shared, with policy enforcement and role-based serving.
Choose sources → to get a library of your own and a daily brief.