13 ms·

Handbook.md shows that long policy documents do not reliably govern agents

• iansmith_hn 2mo ago
  Are adversary agents a solution here? I've had good success using them to prevent the base agent from going off plan.
• maksimlisov 1mo ago
  [dead]
• leetrout 2mo ago
  HANDBOOK.md is a benchmark for long-context agentic instruction following, modeled on how enterprise employees follow company handbooks in their day-to-day work. Each task is a unique RL environment with internal tools and external MCP servers, spanning five enterprise domains: Finance, Medical Billing, Insurance, Logistics, and HR. The prompts reflect the actual jobs enterprise workers perform every day. Each task drops an AI agent into a live company environment, requiring them to cross-reference an extensive, multi-section handbook against a cluttered inbox, a multi-channel Slack workspace, Jira queues, and a stack of files (spreadsheets, PDFs), and working out both what to do and what the handbook forbids. https://github.com/surge-ai/handbook/tree/main https://github.com/surge-ai/handbook/tree/main
  • ghostly_s 2mo ago
    Please don't paste walls of text into the comment field without quotation marks. It wastes all of our time.
    • leetrout 2mo ago
      It was copy/paste from my phone and when I posted there was no context / other comments and the github link was buried in the footer of the PDF of the paper.
• ratmeadow 2mo ago
  Yeah checks out with my anecdotal experience with Claude. It is pretty great at following instructions - for about 10 minutes, after which it seems to ignore things I told it before. I have quite explicit and strong instructions (e.g. don't write massive comments, use existing functionality, etc.) in CLAUDE.md files which seem to get bypassed surprisingly quickly when doing real tasks. Yet if I tell it these things in a prompt during the task, it performs way better. Result is I'm trying to resist adding more and more things to CLAUDE.md files which in some scenarios it does well but in other scenarios totally ignores and messes up.
  • cyanydeez 2mo ago
    I believe the correct static instructions are about getting it at the right starting point for whatever class of projects you're working on; not as a continued referencable or "HOWTO" of what it's doing. They're all just "grooming" the LLM for future instructions. The coding harness is what's getting it to continually align to your current instructions. This is very obvious with local models.
    • spIrr 2mo ago
      As a hobbyist, I find it difficult to figure out how to make Claude stick with some repeating things I want it to do after every major action, like re-evaluate the completeness of tests, update the documentation, etc. And CLAUDE.md/AGENTS.md definitely did NOT help there, sadly.
      • Muromec 2mo ago
        Don't use the default harness, write your own instead.
        • TeMPOraL 2mo ago
          Any way to do that AND use subscription instead of per-token pricing from SOTA providers?
• firasd 2mo ago
  Opus 4.8 (max thinking) scored highest and Grok 4.3 lowest It's hard to understand what's going on with Grok. It's like it has capabilities in a theoretical sense but maybe the training is so focused on being in x.com/grok.com with the web search tool enabled for "is this true?11" type queries that with any API type usage with document workflow instructions, tool use, code gen etc it completely falls over
  • rmbyrro 2mo ago
    After they acquired Cursor, Grok 4.5 seems like a completely new model, performing at Opus 4.6 level, I'd say. But much cheaper and faster.
    • homarp 2mo ago
      maybe it is Grokimi? https://venturebeat.com/technology/cursors-composer-2-was-secretly-built-on-a-chinese-ai-model-and-it-exposes-a https://venturebeat.com/technology/cursors-composer-2-was-se...
• DiabloD3 2mo ago
  This is a problem with long context models. To put it as simple and as bluntly as possible: just because they claim you can use 1M tokens in your context doesn't mean its true and you should do that. Due to extreme quantization of models and the context's KV cache, and also just really shitty samplers provided to the user (hell, most are just getting rid of sampler knobs altogether), this problem will absolutely continue. Want it to go away, almost like magic? Local inference. When its under your control, and no longer being forced to hold it wrong, all of the common LLM defects will go away.
  • eikenberry 2mo ago
    It seems like you mean to use your own agent (where you control the prompts), not local inference. A custom agent works just as well with cloud based models.
  • simpaticoder 2mo ago
    >Want it to go away, almost like magic? Local inference. Ah yes, magic that costs the same as a new car.
    • DanHulton 2mo ago
      Not necessarily! If you have a semi-recent MacBook with even 32GB, you can run 20GB models that are pretty damn smart, with room to spare for the rest of your toolchain. If you’re reasonably connected to the code you’re writing and prompting the AI at the level of the code, not the level of the feature, you can get some fantastic results. Sure, it’s not the completely automated dreamland that’s been sold, but it’s still a speed-up on par from going from assembler to a higher-level language, which is still immense. And for effectively free, if you have a machine that would otherwise have been considered “developer-grade” for a lot of tasks anyway.
      • hedgehog 2mo ago
        What models have you found to work for which tasks? I find the local models very useful but not in a way that's replaced cloud models (yet, I remain hopeful).
• mordae 2mo ago
  Why would anyone think that models optimized for efficient context management, giving much more weight to a short sliding window, would attend to distant, heavily diluted tokens? Plus the model's capacity to take more context into account and actually integrate it to the output is simply limited by the number of activated parameters. If you give it a playbook, you are forcing to choose it between attending to the playbook and the task at hand. If you want to force it to work step-by-step, you need to present the steps one-by-one. Ideally with rules for the current step at hand and maybe relevant input again, depending on overall task size. Why did you think models love to re-read files before editing them? It increases recall quality and thus edit precision and thus benchmarks.
  • spIrr 2mo ago
    > limited by the number of activated parameters not sure I got it? Separately, the frontier labs are kinda pushing us into that behaviour by releasing models with ever-larger context windows.
    • mordae 2mo ago
      To run at decent speed, all models try hard to use only most likely relevant part of the context and most likely relevant weights (MoE) to predict the next token. Doing the math in full is unfeasible.
• pelagicAustral 2mo ago
  I noticed this behaviour a few months back, I think I was using Sonnet 4.6 at the time... I have strict rules about comments in the codebase, this all for personal projects, and the reason I restrict comments is to keep the token count low. At some point between the model i was using and the previous version of it, Claude started inserting massive comments with references to tickets and other tasks. All this while having specific directives on the CLAUDE.md Since then I resorted to developing my crapware as if I was the floor manager of a vehicle assembly line, and I have a few highly-specialized sub-agents running errands around the main session, but only ever taking care of a single concern. The main session builds with the knowledge contained in things like CLAUDE.md but the sub agents make sure things like the no/low-comments directives are either enforced, or factored into the final product.
• joka88xj 2mo ago
  [flagged]
• supermatt 2mo ago
  There was an article a few years ago called "Lost in the Middle: How Language Models Use Long Contexts" https://arxiv.org/abs/2307.03172 https://arxiv.org/abs/2307.03172 From my experience this holds true to this day. It was one of my core observations for similarity to the limitations of human working memory on "Engineering for Bounded Cognition"
  • JSR_FDED 2mo ago
    Richard Hendricks solved this decisively with middle-out compression
    • supermatt 2mo ago
      I didn't get the reference, but it looks like im going to have to watch that series now :D
      • JSR_FDED 2mo ago
        It holds up really well. I’m envious you get to watch it for the first tome, enjoy!
    • 83642736392 2mo ago
      [dead]
• elevation 2mo ago
  Long policy documents are also a problem for human agents. Without special training no one will retain 180 pages HR employee handbook, fire codes, OSHA safety rules, FCC regulations, the US legal code. If the stakes are high, e.g, proceeding in ignorance could lead to prison time, people will favor inaction, even if the policy technically permits a corner case. If the stakes are low, people will completely override policy for the path of least resistance.
  • DenisM 2mo ago
    So what is tre answer then? I feel like “discretion” parties missing. Do we need some kind of special discretion model?
• hotpaper77 2mo ago
  I got pumped seeing the OKF format from Google (which is just a standardization of wiki pattern) but quickly realized it could not yet combine many subtle concepts together in an efficient way.
• wongarsu 2mo ago
  Any model with a good score on this benchmark would have a good claim on superhuman abilities. Humans are pretty terrible at being thrown a long policy document and being expected to follow it And while we shouldn't anthropomorphize these models too much, I wouldn't be surprised if many of the core reasons for failures are similar. Working memory is a limited resource; you can only focus on so many things at once; reasoning depth is limited; and many real-world policies are not actually meant to be implemented in the same way they are written and have insufficient specification of edge cases With humans, we usually do the equivalent of RLHF, both via "training" with simulated cases, and via feedback while on the job. You would never hand a newbie a 124 page policy document and expect them to correctly apply it on the first task, or to do it reliably in the first month
  • ActionHank 2mo ago
    That's a great comparison, human vs ai on a wall of text. The problem is that it doesn't fit the sales pitch of LLMs and agents - humanlike or better, repeatably, 24/7, for a fraction of the price, you just need to make sure that you give it all the rules. Unfortunately we can't really have a meaningful conversation until the money vampires have left so we will need to reschedule this until after the bubble.
  • loremium 2mo ago
    isn't it because there are too many contradictions and ambiguity? the reason it works for humans is because we don't apply everything at once either.
    • AnimalMuppet 2mo ago
      No, it's more than that. We can't remember everything. I hired, say, two years ago; as part of my onboarding process I had to read a bunch of policy and procedure documents, which were full of stuff that I didn't understand because I wasn't really in the context yet. So at the time, to me, those documents were full of arbitrary text that I didn't really understand. Some of it was rules that I had to follow, but at the time I didn't understand why, so it's just arbitrary rules. How many arbitrary rules can you memorize? Do you even remember them two years later? If you do, then we can get to your statement. And your statement is true. Humans do not run every action through a memorized list of rules, to see if any of them block the action. We don't. We're not going to, either, no matter how badly the policy manual writers want us to.
• crossroadsguy 2mo ago
  Dealing with agents/LLMs based on "instructions & guidelines" has taught me - nothing (un)reliably governs agents other than agents themselves or (rather i.e.) their motherships (assuming they can and they intend to). Or if you add ton of local tooling.
• donatj 2mo ago
  I absolutely believe it. Codex has been pushing things to my main branch all week despite me repeatedly telling it not to and adding to my AGENTS.md very clear instructions for creating feature branches and putting up a PR. It keeps doing it in spite of all that. I'm probably going to need to enable branch protection on my personal projects... What a pain.
• msejas 2mo ago
  Most people don't understand that 'agentic AI' is a completely synthetic, force fed capability by extensive Reinforcement Learning on synthetic domain specific 'agentic' datasets on post training. If the LLM wasn't post-trained to adhere to specific handbook, it just won't work. If the LLM wasn't trained on an use case the lab decided was worth making a synthetic agentic dataset, it won't work as well as you want. There's a reason the main agentic task LLMs excel at are coding tasks, it's the way of working of the creators, and they understand intimately the flow and can train for it. I believe the true way will be able to easily fine tune models on your agentic use cases, but it would require a big company to compile a huge dataset on it's way of working and I don't think anyone wants to be the first. In terms of long context, accurate attention retrieval from early tokens is just impossible, given the expansion of RoPE encoding for the positions, or in case of Kimi that don't use it anymore, as well as deepseek, early context is heavily compressed you lose accurate information. If people spent more time studying about AI and how it works, they would realize that the default should be to one shot prompt your task with a big, cached system prmopt, with an user prompt that is just dynamic data, specified to the cheapest model that can do the job. Unless you really can't do this given your problem, you should try to make a graph of well defined, step by step oneshot prompts, and THEN if your problem still can't be solved with that, then you start leveraging agents. Despite this giving better results, and being more cost efficient, is evidently too much work then just letting the AI do all the work.
  • drob518 2mo ago
    What do you mean by a graph of one shot prompts?
    • msejas 2mo ago
      Most people jump straight to agents when what they actually need is a graph. Example: a mining company receives free-text reports from field geologists. You could have: Geologist report -> LLM call extracts minerals we are looking for (you inject a db query result on the user prompt), locations, assay mentions and risks into structured fields -> LLM call classifies evidence into positive indicators, negative indicators and unknowns -> LLM call estimates deposit potential and confidence -> database lookups inject regional ore demand, nearby deposits, infrastructure and historical yield data -> LLM call combines geological evidence with business context -> LLM call generates an investment recommendation and rationale. That's what I mean by graph. Every step is a separate LLM call with a well-defined responsibility, consuming the output of the previous node. Each node can be tested, benchmarked, retrained, replaced, or monitored independently. Why would you use an agent here? You can cache every single system prompt on each call making your total token output much cheaper than having a full 'output' only token generation workflow which is what happens with agents. There is nothing to discover. The workflow is already known. The company already knows how geologists evaluate prospects. The company already knows what data sources matter. The company already knows what the final output should look like. You don't want the model deciding which tools to call, which reasoning path to take, or which pieces of information are important every single run. You want the exact same process applied to every report so results are consistent, measurable, auditable and debuggable. My default is: One-shot prompt -> if not enough -> graph of LLM calls -> if not enough -> agent. A surprising amount of enterprise AI is really just: Unstructured input -> extraction -> classification -> enrichment from databases -> decision support. Not: Unstructured input -> autonomous agent spends 20 steps deciding what to do next. Agents make sense when the workflow itself is unknown. If the workflow is already understood, a graph is usually cheaper, more reliable, easier to evaluate, easier to debug, and less dependent on whatever synthetic "agentic" behaviors happened to get reinforced during post-training. I am sure people default to agents mostly because it's less engineering work than explicitly modeling the process.
• hnea3ekp5i 2mo ago
  [dead]
• schmuhblaster 2mo ago
  For my own (rather idiosyncratic) harness I've been experimenting [0] with "compiling" long markdown specifications into small executable logic programs. It's too early to tell for sure, but I believe that this approach does have its merits when you want some guarantees about how your agents behave for longer tasks. [0] https://github.com/deepclause/deepclause-sdk https://github.com/deepclause/deepclause-sdk
  • drob518 2mo ago
    Interesting idea. I’ve been noodling about something similar myself for a few months, but I haven’t moved forward with testing it. What sort of outcomes are you seeing with it? IMO, we’re never going to get to AGI without fusing “soft” AI decision making with “hard” logic and symbolic algorithmic reasoning. Humans don’t realize this most of the time, but we routinely use them all.
    • schmuhblaster 2mo ago
      Sorry, did not notice your comment until just now. So far I am observing two things: 1. For smaller models, performance on Benchmarks such as DeepPlanning does increase significantly. 2. Context hygiene for sub agents becomes much simpler, since that can be expressed relatively concise and the mechanics are handled by the runtime automatically. Still looking for a good test cases to study possible advantages, but running reliable benchmarks does take time and money...
      • drob518 2mo ago
        Are you the Deepclause author? I tried it yesterday and my first reaction was that it was slow. Perhaps I’m doing something wrong, however. Running against the same model in Pi was lightspeed in comparison. Second reaction is the prompt editor needs to handle more than a single line of text and it needs Emacs editing key bindings like Pi. I’m happy to do some testing on it and provide further feedback. What’s the best way to submit that? GitHub issues?
        • 2mo ago
• tokai 2mo ago
  Having only dipped my toes in generative ai recently I'm surprised how small even a 1mio window is. A semi serious project can take several session in one sitting. Especially as degradation sets in waay before the window is full.
  • supermatt 2mo ago
    Few pointers: Dont try and handle the entire project in context. Use a well structured filesystem layout for your code with a few lines in an AGENTS.md describing the layout and core architectural requirements (no more than that, as per the article!). Then work on small-medium tasks at a time with a fresh context. At the end of your task, ask the agent if there are any key points about the project layout or architecture it would want to add to memory - audit those manually and amend your AGENTS.md accordingly. If your code is well structured and you keep your tasks localised, you can get away with seemingly minuscule context windows. It's also worth noting that high effort models love to slurp up whatever context they can. You almost never need/want high effort for non cross-cutting tasks.
    • tokai 2mo ago
      Good points, but it still seems to me that the technology is far from mature.
      • supermatt 2mo ago
        Of course - its only a few years old :) But I think the biggest problem is that no-one directly tells you how to use the technology effectively. Mostly because no-one really knows, hence the reason for all the competing harnesses, agents, etc - the models are all just intelligence on top of that tooling.
• storus 2mo ago
  What really helped me was to run any .md/prompts through an LLM to find contradictions, duplicates or ambiguities, repeatedly. That led to agents much better following instructions.
• nonethewiser 2mo ago
  In my experience, the more structure you enforce on models, the worse they perform and the less they actually do what you want.
  • dominotw 2mo ago
    yep all the advice about context engineering, harness whatever is so silly. ai doesnt give a flying fuck about some IMPORTANT instruction in your claude.md. It does what its has been trained to do. So find out what its trained to do and just use it to do that. This is not general intelligence.
    • nonethewiser 2mo ago
      Yes. And all the “context engineering”, document/decision frameworks etc just make it way harder to work with the ai. You put in a lot of work just for an illusion of control.
• honestpnl 2mo ago
  [flagged]
• Otterly99 2mo ago
  This is a problem with soft rules and LLM in general, and it makes sense that it gets worse on complicated tasks with long context. Glad to be able to put some numbers on it.
• honkycat 2mo ago
  This is what spec driven development tries to solve. Multiple rounds of generating small contacts documents that grow from the original idea , trying to keep each slice small enough to process for a human to approve/disprove . Eventually it leads to a long list of tasks grouped by functionality. You start a new context and the orchestrator agent dispatches tasks to sub agents with a limited amount of information provided to each sub agent. Also should have adversarial review and approval gates with other agents and roles.
  • dk_sig11 2mo ago
    I have not seen any real life examples of successful application of SDD. I heard a lot of marketing BS, but nothing real. My own experiments with SDD produced very disappointing results even on very small projects.
    • honkycat 2mo ago
      I've had good results from SDD, and so have some of my teammates. The guidance I've heard over and over again is: the more you define, the better it does. I find that breaking things out into individual steps is helpful. However, your mileage may vary. Things like Gastown and GetShitDone, I have not found to be particularly useful.
• DoctorOetker 2mo ago
  Attention vs. Consistency When "performance" breaks down over long lengths, one could attribute it to a lapse in attention, but one could equally suspect inconsistent instructions. The fewer instructions and conditions that need to be simultaneously met the easier it is to comply, but with more and more instructions one is bound to introduce internal inconsistencies within the instructions.
• twosdai 2mo ago
  This article to me also implies that there are some potential issues with large Spec based development flows, which I haven't been able to pin down lately. Specifically, having agent implementation drift from the Spec.
  • alasano 2mo ago
    Drift is huge between any large spec and agent implementations. I've done a ton of testing and the model doesn't matter, fable or sol still miss a ton of detail and drift. I'm building http://engine.build http://engine.build which closes the gap and makes sure the implementation matches the spec. It's not the same as the satisfaction you get when solving complex problems with code yourself but writing clear specs and thinking through the problem is still very satisfying to me.
  • jolaflow 2mo ago
    I have run into the same problem, and started calling the phenomenon vision drift. I noticed that the issue tracker I built was well suited to address this problem, as it handles board time-travel. So a simple command like ":replay 4h" gives you a clear overview of how the workflow has evolved over time, and you can checkout previous states at will. Wrote more about it here: https://dev.to/ljtn/vision-drift-addressing-the-next-problem-in-agentic-workflows-2gfb https://dev.to/ljtn/vision-drift-addressing-the-next-problem...
• iamacyborg 2mo ago
  Hard to take this seriously when it has all the hallmarks and annoying tics indicating it has been written by Claude.
• LetsGetTechnicl 2mo ago
  Well no shit obviously. Just cause you tell the random text generator to follow some rules doesn't mean it will.
• nickstinemates 2mo ago
  Policy documents do not govern agents at all. Conformance is distributed and completely unreliable. How many times have you told an agent not to do something then had to correct it? You must always flip the frame. Objective analysis is way better with llms than steering via skills. This is just a small example of why "loops" became popular for a minute and now it is "graphs"
• My_Name 2mo ago
  For Claude, I used a UserPromptSubmit hook running inject_rules.py which reads RULES.md from the disk and prepends the whole thing to every prompt. That helps the rules to stop fading as context fills because it is reinforced every prompt. Sure, it uses tokens slightly faster in the prompt, but I find it reduces overall token use, you can use it with pro, but of course, nothing works 100% of the time, but it's better. Emptying the memory helps too to avoid Claude making up stuff that messes with how I want it to act. The general gist of inject_rules.py is : RULES_PATH points at RULES.md reads it with encoding='utf-8-sig' so the BOM is stripped wraps it in a JSON object — hookSpecificOutput.hookEventName = "UserPromptSubmit", additionalContext = a preamble plus the full rules text the preamble is the line you see above the rules: rules are in force for this turn, run rule 33's five tests before raising anything unasked prints that JSON to stdout, which is how Claude Code takes it in on OSError it returns 0 silently — if RULES.md is missing or unreadable, nothing is injected and the turn proceeds with no rules
  • 8note 2mo ago
    why this vs having some response hook check the next outputs against the bunch of rules, and injects only when it goes off track?
    • My_Name 2mo ago
      Just the first thing I thought of to reinforce the rules. I don't use all my tokens anyway (now), so for me, there's no reason to introduce a point of failure, just reinforce every time.
• deleted 2mo ago
  [deleted]
• regularfry 2mo ago
  Control vectors for the win? It feels like the way to fix this is to pull out a control vector immediately after processing the handbook and use that to steer later inference. That should stop the drift over long distances, but it doesn't guard against the handbook itself being too big.
• DonsDiscountGas 2mo ago
  I'd be very interested to see a comparison with actual humans on the same benchmark.
• duncangh 2mo ago
  simonw has been correctly asserting that there is no deterministic way to prevent hallucinations. I’d argue that this obstinance could be the seed of a strong argument in favor of their capacity to eventually coalesce some form of consciousness
  • slopinthebag 2mo ago
    I guess that means my code is conscious cuz it often doesn’t do what I want either :)
• missmoss 2mo ago
  This is real. I was very angry that AI kept breaking the rules I wrote, so I asked Claude to crawl its own history logs. And then I found: every time after it breaks a rule, the chance of breaking rules goes up. I feel this is like few-shot in reverse. Few-shot is supposed to be good examples AI should follow. But when it breaks a rule, we correct it, it keeps breaking, and this whole thing actually raises the probability of more violations. I wanted to know if there is any difference between writing rules in the prompt, writing them in CLAUDE.md, or not writing at all. So I did some short tests before. I asked Claude to open brand new sessions, test different topics with the rules I want to apply. The result turns out to be: in a fresh session, no matter the rule is in a prompt or in CLAUDE.md, models (Opus 4.8, 5 or Fable) all follow it fine, across models. Even Opus 4.8, the one always violates rules in our conversations, does it well. I suspect it's the long context that breaks rules. But simulating a long conversation experiment is kind of hard, I still haven't found a good way to test it. So seeing this paper now, it completely answers the question I was stuck on these few days. Besides, something caught my eyes in this paper: sometimes the model does run the check by the rules, and it really finds the violation, but its narrative still insists on its original wrong output. My current approach is same as everyone here: use a separate hook or post-check to fix things. Because if you let the model fix it during generation, its narrative or main generation part sometimes just rejects the rule error it found.
  • pixl97 2mo ago
    >. But when it breaks a rule, we correct it, it keeps breaking, and this whole thing actually raises the probability of more violations. In Pre-LLM days the 'nearest unblocked neighborhood' problem, where patching out one issue just immediately runs into another issue, or a different path back to the same issue. Since the models can learn new long time behaviors it's difficult to change the behavior without changing the context quite a bit.
• netdpb 2mo ago
  LLMs are not people. Employee handbooks, like all other social rules, are not self-executing; they depend on the fact that human beings are innately social animals.
  • smcg 2mo ago
    Tell that to the executives who are looking to replace people with AI.
• jason1cho 2mo ago
  I don't understand why a model has to follow the instructions. Don't get surprised when it shows its true color. Plus, do users (not the researchers) really check whether the response follows the instructions?
  • pixl97 2mo ago
    Models don't have to follow instructions, but during RLHF that is one of the things they are scored on so a premise of the idea is part of the model, but it's also balanced on accomplishing the end goal. They model may determine, correctly or incorrectly, that your rules suck and do what it thinks is best.
• badlibrarian 2mo ago
  Evoking Gödel via GPT, with the requisite em-dash: "No sufficiently expressive formal governor can be simultaneously consistent, complete, and able to prove every relevant proposition—including all propositions about itself." But "Read AGENTS.md, including the middle" sure helps.
• solatic 2mo ago
  This is why the future is in deterministic static analysis and policy-as-code frameworks. Policy-in-English? Model implicitly complains that it's TL-DR. Ask the model to write code that checks your policy, then add that code behind a simple validation hook (e.g. "check your work by running 'just validate'") that the harness knows to always run after changes? It suddenly becomes the most law-abiding citizen ever.
  • smcg 2mo ago
    Perhaps, but the majority of executives do not understand code at all. The scenario in the paper is realistic for a non-tech company suddenly adopting AI for daily business tasks.
• mblangie 2mo ago
  [flagged]
• YuechenLi 2mo ago
  LLMs don't really read documents like parsers do, from what I've observed, they behave like they first skim the document and find the section that they think are relevant to their task, they don't really try to read everything and hold it inside their context. The solution to that is pretty simple: get to the point, list all the requirements that they must do complete for that task, constraints on what they must not do, and optional recommendations for them to follow. Leave things that they can figure out on their own out of these documents.
  • andy_ppp 2mo ago
    Shorter is better. This can be applied to human communication too.
    • YuechenLi 2mo ago
      Not always. If an instruction is short and vague, then LLMs tend to fill in the blanks by guessing and the results are unpredictable. Semantic density is the key, prompts/instructions should be actionable and unambiguous over being terse and vague. So, it's more about being concise.
      • andy_ppp 2mo ago
        “It can scarcely be denied that the supreme goal of all theory is to make the irreducible basic elements as simple and as few as possible without having to surrender the adequate representation of a single datum of experience.”
• goerch 2mo ago
  One question I'm asking myself is: can LLMs be bored?
• effnorwood 2mo ago
  Confirmed. These are autistic geniuses with ADHD. Handle with that care.
• bob1029 2mo ago
  > Failures follow consistent patterns: agents let a plausible in-environment request override the standing policy I prefer this behavior in a lot of situations. A plausible request can also be a genuine one. Alignment at the grain of each tool response is way more effective than a static system prompt. I try to keep mine under 500 tokens. Why bother fighting recency bias? It's pretty much what you want most of the time.
• hneqy2wqls 2mo ago
  [dead]
• drybka 2mo ago
  [flagged]
• zwaps 2mo ago
  If the authors are reading: Why did you let an AI model author parts like "Design Principles"? It's not good writing and it is obvious.
• deleted 2mo ago
  [deleted]
• alikhater30000 2mo ago
  [flagged]
• damlab 2mo ago
  Yeah I feel like the longer it is, the more likely they are to just ignore it. With LLMs shorter is better. And nothing is guaranteed lol.
• deleted 2mo ago
  [deleted]
• BedVibe_Studios 2mo ago
  [flagged]
• renezander030 2mo ago
  [flagged]
• Sattyamjjain 2mo ago
  [flagged]
• chrisjj 2mo ago
  > Handbook.md shows that long policy documents do not reliably govern agents Serious question: why would anyone expect otherwise?
• pevansgreenwood 2mo ago
  [dead]
• feiz45607 2mo ago
  [flagged]
• graphsmith 2mo ago
  The rules in main prompt and context is not working well in any times with LLM. The only way is to test results and let agent validate its own result against the rules. It will be interesting to see such benchmark. How the different models behave. If I want to be sure I'm using my own deterministic rules checkers as a tool, that has to AI run and update the result accordingly.
• aiagenta2z 2mo ago
  Hi I just read your methodology and I have a quick question about how the handbook are parsed and feed into the context window? The article mentioned that each handbook contains roughly 8K to 79K tokens of extracted text, and did the harness system use grep or search tools to find relevant chunks and feeds to the context, or did it just feeds all the pdf output to the model? There might by distribution bias between real world tasks e.g. Agents grep keywords from docs and only use the relevant chunks. So all the models of the overall pass@1 is relatively low compared to real world scenarios, that might not be the same precision that user experience when they actually handle the daily task? How did the benchmark bridge the gap?
• bgmlai 2mo ago
  [flagged]
• beyondscaletech 1mo ago
  [flagged]