14 ms·

Agents need control flow, not more prompts

• afxuh 5mo ago
  thats why agents completes a project with the first 3 prompts, , then maintaining and fine-tuning it take ages till hits "-Session token expired"
• Neywiny 5mo ago
  If you're trying to get reliability and determinism out of the LLM, you've already lost
  • tekne 5mo ago
    Wait... why? Making an unreliable, nondeterministic system give reliable results for a bounded task with well-understood parameters is... like half of engineering, no? There's a huge difference between "generate this code here's a vague feature description" and "here's a list of criteria, assign this input to one of these buckets" -- the latter is obviously subject to prompt engineering, hallucination, etc -- but so can a human pipeline!
    • Neywiny 5mo ago
      Because it's not possible. There is nothing you can say to the LLM that will guarantee that something happens. It's not how it works. It will maybe be taken into consideration if you're lucky. But if you're trying to tell me that every time you list criteria you get them all perfectly matched, you're clearly gifted.
      • gf000 5mo ago
        I'm being deliberately pedantic, but depending on what kind of representation we use for the neural network (due to rounding) as well as the choice of inference (that is, given a distribution for next token, which one to choose), it can absolutely be reproducible and completely deterministic. Though chaotic, which I believe is the better word here - a single letter change may result in widely different results. We just choose to use more random inference rules, because they have better results.
        • Neywiny 5mo ago
          With determinism you're not wrong. The problem is that you'd need to make sure all your seeds, temperatures, and other input parameters are exactly the same, and importantly that all context is cleared. But people don't do that. And I'm not sure every if even any provider lets you set those parameters.
          • gf000 5mo ago
            Even with temperature set to zero, I believe due to FP operations not being commutative you may still get non-determinism, so what I am talking about (as mentioned, very pedantically) is mostly the theory.
      • tekne 5mo ago
        "There is nothing you can say to the person that will guarantee that something happens"
    • JCTheDenthog 5mo ago
      >the latter is obviously subject to prompt engineering, hallucination, etc -- but so can a human pipeline! ...which is why we write deterministic code to take the human out of the pipeline. One of the early uses of computers was calculating firing tables for artillery, to replace teams of humans that were doing the calculations by hand (and usually with multiple humans performing each calculation to catch errors). If early computers had a 99% chance of hallucinating the wrong answer to an artillery firing table, the response from the governments and militaries that used them would not be to keep using computers to calculate them. It would be to go back to having humans do it with lots of manual verification steps and duplicated work to be sure of the results. If you're trying to make LLMs (a vague simulacrum of humans) with their inherent and unsolvable[1] hallucination problems replace deterministic systems, people are going to eventually decide to return to the tried and true deterministic systems. 1: https://arxiv.org/abs/2401.11817 https://arxiv.org/abs/2401.11817
      • tekne 5mo ago
        So how did we deal with the human mistakes? You mentioned it: - Get humans to check each other's work - Systematize the process -- breaking it down into smaller and smaller tasks where the likelihood of mistakes decreases - Replace as much as possible with deterministic code There's absolutely no reason you can't do this with LLMs -- and it might help quite a bit since LLMs are cheap. There's also hybrid systems -- where human checkers are replaced or augmented with LLM checkers. For example -- I have an LLM check all my scientific papers for typos and minor errors. It's caught quite a few, and when it caught something that was not actually an error, it was usually something whuch would benefit from clarification anyways. Now -- if I could afford to pay a grad student to do that, would be even better! But I can't, and if I could, not all the work which warrants a few cents of tokens warrants a few hundred dollars of tedious grad student labor -- especially when the latter has a very strong incentive to say LGTM (nothing here is life critical!) Likewise, we could imagine: - A deterministic process with a heuristic + an LLM in the loop checking, for example -- "is this likely correct?" -- perhaps escalating to a human (or a bigger LLM) in case of anomaly. I can see this being amazingly useful for automated refactors. - Automatic paperwork/customer service processing -- if the cost-of-failure can be bounded (say X$) and testing shows failure happens on average only reasonably often (say Y% of the time) -- it might be cheaper to run an AI system and eat that cost, especially if continuous monitoring lets you know if you have to "shut it down." In both cases -- there's nothing stopping an LLM from potentially having better-than-human average performance, and perhaps delegating real edge cases to actual experts. Remember: you're not competing with motivated PhDs, you're competing with minimum wage labor reading a list of instructions which is like a prompt except poorly formatted and missing steps.
  • aleksiy123 5mo ago
    There’s a whole range between completely random and completely rule based deterministic. Somewhere in between that I guess is the varying levels of intelligence more likely able to make the “right” decision for anything you throw at it.
  • pydry 5mo ago
    This is something I think some people are fundamentally not capable of understanding.
  • evantbyrne 5mo ago
    I would hope that when engineers speak of LLM determinism they just mean it as shorthand for close to 1 under expected conditions
  • sudosteph 5mo ago
    I mean, with reliability there's a spectrum. If the risks that an unreliable outcome brings aren't all that bad, then sometimes it's worth it to chase "my agents made an acceptable PR 70% of the time, can I get it to 90?" Determinism is a different matter. Scripts and hooks are really the main levers you can pull there, but yeah - a a decent script and a cron job will handle certain things much better (and for a fraction of the cost)
• bwestergard 5mo ago
  I agree with the sentiment, but I think the conclusion should be altered. When you hit the limit of prompting, you need to move from using LLMs at run time to accomplish a task to using LLMs to write software to accomplish the task. The role of LLMs at run time will generally shrink to helping users choose compliant inputs to a software system that embodies hard business rules.
  • edgarvaldes 5mo ago
    Some have expressed the opinion in this forum that the future of software lies in programs that are created and adapted at runtime, using genAI. I don't know how far we are from that.
    • mjr00 5mo ago
      > Some have expressed the opinion in this forum that the future of software lies in programs that are created and adapted at runtime, using genAI. Good luck with that. Users will flood you with complaints if a button moves 5px to the left after a design update. A program that is generated at runtime, with not just a variable UI but also UX and workflows, would get you death threats.
      • hilariously 5mo ago
        I think many software adjacent folks are super excited because they can now have the personalized toothbrush they keep asking people to make for them. The problem is that outside of that most people want boring and regular interfaces so they can get in and solve the problem and get out - they don't want to "love" it or care if its "sexy" they want it to work and get out of the way. LLMs transmogrifying your software at ever request assumes people are software architects and creators who love the computer interface, and that just doesn't describe the bulk of the population. Most people using computers use the to consume things or utilize access to things, not for their own sake, and they certainly don't think "what if I just had code to do x..." unless x is make them a lot of money.
      • munk-a 5mo ago
• AIorNot 5mo ago
  I mean we have Langgraph, BAML etc
• apalmer 5mo ago
  Generally agree with this stance case in point: the breakthrough in ai coding was not that AI intelligence increased as much as that a lot of the core process execution moved out of the LLM prompt and into the harness.
• eth415 5mo ago
  agreed - this is what we’ve been trying to build at scale. https://github.com/salesforce/agentscript https://github.com/salesforce/agentscript
  • crsn 5mo ago
    Ditto Ethan's point -- and hundreds of customers tell us it works very well. We'd value more feedback from this community, not just the Salesforce/Agentforce customer base!
• Linell 5mo ago
  [dead]
• droolingretard 5mo ago
  Are you the guy who used to write MapleStory hacks?
• astrobiased 5mo ago
  It's the right direction, but control flow introduces limitations within a system that is quite adaptable to dynamic situations. The more control flow you try to do, the more buggy edge cases that pop up if done poorly. Still have yet to see a universal treatment that tackles this well.
  • TuringTest 5mo ago
    I would just reverse the architecture of the whole system. Build a classic deterministic program, and use LLMs as heuristics adapting the system to the environment - the functions that you call on the 'if's and 'switch' statements to decide where the system should go. I see this as the most robust way to build a predictable system that runs in a controlled way while taking advantage of probabilistic AIs while reducing the impact of their alucinations. LLMs simply can't be trusted to follow instructions in the general case, no matter how much you constraint them. The power of very large probabilistic models is that they basically solved the _frame problem_ of classic AI: logical reasoning didn't work for general tasks because you can't encode all common sense knowledge as axioms, and inference engines lost their way trying to solve large problems. LLMs fix those handicaps, as they contain huge amounts of real world knowledge and they're capable of finding facts relevant to the problem at hand in an efficient way. Any autonomous system using them should exploit this benefit.
• jerf 5mo ago
  This is why I frequently refer to "next generation AIs" that aren't just LLMs. LLMs are pretty cool and I expect that even if we see no further foundational advancement in AIs that we're going to continue to see them exploited in more interesting ways and optimized better. Even if the models froze as they are today, there's a lot more value to be squeezed out of them as we figure out how to do that. However, there are some things that I think need a foundational next-generation improvement of some sort. The way that LLMs sort of smudge away "NEVER DO X" and can even after a lot of work end up seeing that as a bit of a "PLEASE DO X" seems fundamental to how they work. It can be easy to lose track of as we are still in the initial flush of figuring out what they can do (despite all we've already found), but LLMs are not everything we're looking for out of AI. There should be some sort of architecture that can take a "NEVER DO X" and treat it as a human would. There should be some sort of architecture that instead of having a "context window" has memory hierarchies something like we do, where if two people have sufficiently extended conversations with what was initially the same AI, the resulting two AIs are different not just in their context windows but have actually become two individuals. I of course have no more idea what this looks like than anyone else. But I don't see any reason to think LLMs are the last word in AI.
  • cultofmetatron 5mo ago
    heres a fun one for you https://www.youtube.com/watch?v=kYkIdXwW2AE&t=315s https://www.youtube.com/watch?v=kYkIdXwW2AE&t=315s
  • cheesecakegood 5mo ago
    Actual memory, in my opinion. Right now memory is broadly speaking like a system of sticky notes the AI writes itself and checks every time, rather than an integrative system that allows learning and can trigger more flexibly.
    • DmitriyBuchilin 4mo ago
      [dead]
• huflungdung 5mo ago
  [dead]
• solomonb 5mo ago
  I agree and I think a really wonderful way to encode agentic control flow would be with Polynomial Functors. https://arxiv.org/abs/2312.00990 https://arxiv.org/abs/2312.00990
• 59nadir 5mo ago
  This was one of the key insights in Stripe's explanations about Minions[0], their autonomous agent system; in-between non-deterministic LLM work they had deterministic nodes that handled quality assurance and so on in order to not leave those types of things to the LLMs. 0 - https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents-part-2 https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-...
• ModernMech 5mo ago
  Slowly and surely we are replacing AI with programming languages.
• taherchhabra 5mo ago
  I wrote something recently on how agent development differs from traditional software development https://x.com/i/status/2051706304859881495 https://x.com/i/status/2051706304859881495
• onion2k 5mo ago
  Agents are probabilistic systems. A common mechanism to get a reliable answer from systems that can have variable output is to run them several times (ideally in separate, isolated instances) and then have something vote on the best result or use the most common result. This happens in things like rockets and aviation where you have multiple systems giving an answer and an orchestrator picking the result. I've tried doing something similar with AI by running a prompt several times and then have an agent pick the best response. It works fairly well but it burns a lot of tokens.
  • suprfnk 5mo ago
    But then, if an agent picks the best response, how would you know that that is reliable?
    • xienze 5mo ago
      Obviously you have multiple agents justify why they picked a certain response and then create another agent that picks the solution with the best justification.
      • kkyr 5mo ago
        touché
      • DmitriyBuchilin 4mo ago
        [dead]
    • onion2k 5mo ago
      You could get the agents to output something structured and then use a deterministic test if you're worried about that.
  • Yokohiii 5mo ago
    An LLMs "wrong" decision is either systemic or biased. They learn "common sense" from human input (i.e. shared datasets, reinforcement learning). If a decision is flat out wrong for you, asking 10 LLMs is unlikely to help.
• encoderer 5mo ago
  You can get a lot done with agentic programming without going "all in" on a gastown-like system, but I think there is a minimum viable setup: 1. an adversarial agent harness that uses one agent to create a plan and implement it, and another to review the plan and code-review each step. 2. an agentic validation suite -- a more flexible take on e2e testing. 3. some custom skills that explain how to use both of those flows. With this in place you can formulate ideas in a chat session, produce planning artifacts, then use the adversarial system to implement the plans and the validation layer to get everything working e2e for human review. There are a lot of tools you can use for these things but I chose to just build the tooling in the repo as I go.
  • Schiendelman 5mo ago
    Claude already creates multiple agents for some projects just to keep context windows smaller. I don't think it'll be long before they offer a testing agent along with their planning agent.
    • encoderer 5mo ago
      I prefer having codex author plans and implement, and claude play reviwer. I do swap them from time to time and i have a lot of respect for claude 4.6 and 4.7 but for my domain I think codex does a better job with the authoring.
      • Schiendelman 5mo ago
        That's a cool idea! Plus I bet you can stay in lower tiers with both?
        • encoderer 5mo ago
          You're definitely burning more tokens with the back/forth and multi-step approach but assuming you swap who does the authoring from time to time you can definitely get the max out of each plan. Review doesn't use as many tokens.
• gardnr 5mo ago
  This is straight outta 2023: Agents aren't reliable; use workflows instead.
• pandalyt1c 5mo ago
  [flagged]
• rnxrx 5mo ago
  I wonder if a part of the problem isn't just the misapplication of LLMs in the first place. As has been mentioned elsewhere, perhaps the agent's prompt should be to write code to accomplish as much of the task in as repeatable/verifiable/deterministic a way as possible. This would hopefully include validation of the agent's output as well. The overall goal would be to keep the LLM out of doing processing that could be more efficiently (and often correctly) handled programmatically.
  • foolserrandboy 5mo ago
    yup, the standard way of thinking about agents seems backwards and probably costly. Use LLMs to write scripts, then stick all your scripts in your own looping harness and call out for LLMs for those parts that are too hard to automate with some deterministic validation at the end.
  • VMG 5mo ago
    The problem is that often the program runs into some edge case that requires interpretation, at which point one is tempted to let the LLM deal with the edge case, at which point one is tempted to let the LLM deal with the whole loop and let it do the tool calls
    • Fishkins 5mo ago
      Agreed. I think the approach described here is promising. Most of the workflow is deterministic and includes safeguards, but an LLM is invoked in the one case where it's really useful. https://lethain.com/agents-as-scaffolding/ https://lethain.com/agents-as-scaffolding/
  • chrismarlow9 5mo ago
    100% agreed. use the non-deterministic thing that is right 90% of the time to generate a deterministic thing that is right 100% of the time. one of the key things I add to my prompts is: - Please consult me when you encounter any ambiguous edge cases Attaching the AI to production to directly do things with API calls is bad. For me the only use case where the app should do any AI stuff is with reading/categorizing/etc. Basically replacing the "R" in old CRUD apps. If you want to use that same new AI based "R" endpoint to auto fill forms for the "C", "U", and "D" based on a prompt that's cool, but it should never mutate anything for a customer before a human reviews it. Basically CRUD apps are still CRUD apps (and this will always be true), they just have the benefit of having a very intelligent "R" endpoint that can auto complete forms for customers (or your internal tooling/Jenkins pipelines/etc), or suggest (but never invoke) an action.
• briga 5mo ago
  Sometimes it feels like Agents are just reinventing microservices. Except they are are doing it in the most inefficient way possible. It is certainly a good way for the LLM companies to sell more tokens
• oinoom 5mo ago
  this is just advocating for a harness, which has been the focus (along with evals) for at least the last three months by pretty much anyone working with agents professionally or seriously
• yogthos 5mo ago
  This was basically my realization as well. We are trying to get LLMs to write software the way humans do it, but they have a different set of strength and weaknesses. Structuring tooling around what LLMs actually do well seems like an obvious thing to do. I wrote about this in some detail here: https://yogthos.net/posts/2026-02-25-ai-at-scale.html https://yogthos.net/posts/2026-02-25-ai-at-scale.html
  • flowgrammer 5mo ago
    My experimentation with Verblets also concluded plain functions are the most logical harness for LLMs.
• tim-projects 5mo ago
  This is exactly the problem I've been working on and I see others are too. When you implement quality control gates, everything works better. It solves so many of the basic problems llms create - saying code is finished when it isn't. Skipping tests, introducing code regressions, basic code validation etc I am finding that the better the quality gates are the lower quality llm you can use for the same result (at a cost of time).
  • Nizoss 5mo ago
    Exactly! I don’t babysit TDD anymore. I have another agent that does that for me and honestly sometimes catches things I would have missed if I was the babysitting. Hooks do wonders here. The payload contains a lot of information about the pending action the agent wants to make. Combine that with the most recent n events from the agent’s session history and you have a rich enough context to pass to another agent to validate the action through the SDK. This way the validation uses the same subscription you’re logged in to, whether you’re using Claude Code, Codex, or Copilot. The validation agent responds with a json format that you can easily parse and return, allowing you to let the action through or block it with direction and guidance. I’m genuinely impressed by how well this works considering how simple it is. You can find my approach here: https://github.com/nizos/probity https://github.com/nizos/probity
  • DmitriyBuchilin 4mo ago
    [dead]
• arian_ 5mo ago
  Control flow tells the agent what it's allowed to do. It doesn't tell you what the agent actually did. Both matter. Everyone is building the permission layer. Almost nobody is building the verification layer.
  • allynjalford 5mo ago
    I am...
• aykutseker 5mo ago
  all caps in a prompt is a code smell. when you're typing MANDATORY, you should be writing a wrapper, not refining the prose.
  • Nizoss 5mo ago
    Exactly! I have said this a couple of times but it was taken literally as in no capital letters or strong language. Glad to see someone else who shares this perspective.
• JohnMakin 5mo ago
  > Imagine a programming language where statements are suggestions and functions return “Success” while hallucinating. Reasoning becomes impossible; reliability collapses as complexity grows. This is essentially declarative programming. Most traditional programming is imperative, what most developers are used to - I give the exact set of instructions and expect them to be obeyed as I write them. Agents are way more declarative than imperative - you give them a result, they work on getting that result. Now the problem of course, is in something declarative like say, SQL, this result is going to be pretty consistent and well-defined, but you're still trusting the underlying engine on how to go about it. Thinking about agents declaratively has helped me a lot rather than to try to design these rube-goldberg "control" systems around them. Didn't get it right? Ok, I validated it's not correct, let's try again or approach it differently. If you really need something imperative, then write something imperative! Or have the agent do so. This stuff reads like trying to use the wrong tool for the job.
  • repelsteeltje 5mo ago
    I was thinking of declarative, but PROLOG rather than SQL. So with actual control flow and reasoning capabilities. And then you run into similar issues as the llm does, like silent failures, loops, contradictions unless you're very careful. The essence might be the same closed world assumption problem. In llm case this manifests as hallucination rather that admitting it does not know.
  • miltonlost 5mo ago
    SQL's declarativeness is also based on the mathematics of relational algebra, so it will return the same result every time. Will it return it in the same amount of time every single query? No, that depends on indexing and database size. But the query itself won't be altered in the same way an LLM would be.
    • JohnMakin 5mo ago
      Engines that use SQL can vary drastically in how they handle strings, floating points, etc., where identical SQL queries on identical data absolutely can return different results, which is why I mentioned the engine underneath - LLM's being nondeterministic in addition to declarative is kind of tangential to the point I was trying to make. It is the same in terraform - yes, the HCL spec defines things very precisely, but you're kind of at the mercy of how the provider and provider API decide how to handle what you wrote, which can be very messy and inconsistent even when nothing changed on your side at all. LLM/agent usage feels a lot like that to me, in the sense it's declarative and can be a bit lossy. As a result there are things I could technically do in terraform but would never, because I need imperativeness. My main point being, I think people are trying to ram agents into a ton of cases where they might not necessarily need or even want to be used, and stuff like this gets written. Maybe not, but I see it day to day - for instance, I have a really hard time convincing coworkers that are complaining about the reliability of MCP responses with their agents, that they could simply take an API key, have the agent write a script that uses it, and strictly bound/define the type of response format they want, rather than let the agent or server just guess - for some reason there is some inclination to "let the agent decide how to do everything." I think that's probably what this article is getting at, but, I am saying that trying to create these elaborate control flows with validation checks everywhere to reign in an unruly application making dumb decisions, why not just use it to write deterministic automation instead of using agent as the automation?
• xuhu 5mo ago
  It sounds like the "app written in C++ calling Lua scripts, versus app written in Lua calling C++ libraries" debate. Both designs (Lightroom, game engines) have worked successfully. There's probably nothing that prevents mixing both approaches in the same "app".
  • QuercusMax 5mo ago
    This pattern has been described for decades: https://wiki.c2.com/?AlternateHardAndSoftLayers https://wiki.c2.com/?AlternateHardAndSoftLayers. It's not just a matter of who's in control - you can layer these things.
• chandureddyvari 5mo ago
  I had good success with hooks in claude code. Personally I feel this problem was common with humans as well. We added tools like husky for git commits, for our peers to push code which was linted, type checked etc. I feel hooks are integral part of your code harness, that’s only deterministic way to control coding agents.
  • Nizoss 5mo ago
    I fully agree. Also started using husky before expanding further and created my own hooks. I can’t imagine myself using agents today without them, it would require a lot of babysitting.
• jonahs197 5mo ago
  [dead]
• aditgupta 5mo ago
  [dead]
• dnautics 5mo ago
  Yes. Humans are also unreliable and nondeterministic (though certainly more reliable). Accordingly we have built software dev practices around this. I imagine it would be super useful for example to have a "TDD enforcer": Phase 1: only test files may be altered, exactly one new test failure must appear. Phase 2: only code files may be altered. The phase is cleared when the test now succeeds and no other tests fail. If you get stuck, bail and ask for guidance
  • ManWith2Plans 5mo ago
    I've been busy building and dogfooding open-artisan for my own development purposes. I've diverged quite a bit from main and am hoping to merge some of those changes back soon. It's basically an OpenCode plugin that forces open-code token-hungry state machine that tries to map the engineering process I follow, exposing only valid tools and states at every step of development. If you're interested, in following along or trying it out, it's available here: https://github.com/yehudacohen/open-artisan/ https://github.com/yehudacohen/open-artisan/ Hopefully, I'll merge in my large structural changes in the next couple of weeks. These structural changes will enhance the state machine meaningfully, as well as adding support for hermes agenet.
• isityettime 5mo ago
  Afaict all harnesses are wrong in this respect, some of them deeply so. Slash commands, for instance, are a misfeature. I should never have to wait for the chatbot finish a turn so that I can check on the status of my context window or how much money I've spent this session. Control should be orthogonal to the chat loop. Even things that have nothing to do with controlling the text generator's input and output are entangled with chat actions for no good reason except "it's a chat thing, let's pretend we're operating an IRC bot". There are a zillion LLM agents out there nowadays, but none of them really separate control from the agent loop from presentation well. (A few do at least have headless modes, which is cool.)
  • dnautics 5mo ago
    > Slash commands, for instance, are a misfeature. I should never have to wait for the chatbot finish a turn so that I can check on the status of my context window or how much money I've spent this session. Control should be orthogonal to the chat loop. I get what you're trying to say but in practice architecting what you propose is considerably more difficult. Why not build it and try to get hired by one of the bigcos?
    • isityettime 5mo ago
      I don't think the basic architecture principles are novel. The big AI labs and other large tech companies already have engineers who can see this, without a doubt. But the AI labs clearly don't care if their LLM agents are just big balls of mud, and the big tech companies priorities mostly lie elsewhere, too. They just want features. They don't really care about duplicated work, so half of them reinvent the TUI rendering wheel. Pluggability is something that might be actually hostile to their interests in lock-in. And the AI labs probably think "after a couple more scaling cycles, our models will be so good that our agents can just rewrite themselves from scratch"; until they hit a compute or power wall, it always looks rational to them to defer rearchitecting. Another real possibility is that if you work on an agent with a really clean architecture and publish it in hopes of getting hired by some AI company, all of them think "that looks great, but we don't want to rearchitect right now". Your code winds up in the training set, and a year and a half from now, existing agents can "one-shot" rewrites along the lines of your design because they're "smarter". As for me, I'm not that interested, personally. There are other things I want to build and I'm working on those.
• kmad 5mo ago
  This is, at least in part, the promise of frameworks like DSPy and PydanticAI. They allow you to structure LLM calls within the broader control flow of the program, with typed inputs and outputs. That doesn’t fix non-determinism, hallucinations, etc., but it does allow you to decompose what it is you’re trying to accomplish and be very precise about when an LLM is called and why.
• lacymorrow 5mo ago
  [flagged]
• _pdp_ 5mo ago
  Or maybe, just maybe, LLMs do not run deterministicly and that is ok? In the real world almost nothing runs like that - only software and even that has a lot of failures. So perhaps rather than trying to make agents run deterministicly the goal is to assume some failure rate and find compensation control around it.
• kenjackson 5mo ago
  I feel like people forget that they're still allowed to program. You're still allowed to create workflows tying together LLMs and agents if you want. Almost all the tools and technology that existed before LLMs are still available to be used.
• illwrks 5mo ago
  I’ve been building a small ‘agent’ using copilot at work, partly a learning exercise as well as testing it in a small use case. My personal opinion is that AI and agents are being misrepresented… The amount of setup, guidance and testing that’s required to create smarter version of a form is insane. At the moment my small test is: Compressed instructions (to fit within the 8k limit) 9 different types of policies to guide the agent (json) 3 actual documents outlining domain knowledge (json) 8 Topics (hint harvesting, guide rails, and the pieces of information prepared as adaptive cards for the user) 3 Tools (to allow for connectors) The whole thing is as robust as I can make it but it still feels like a house of cards and I expect some random hiccup will cause a failure.
  • dnh44 5mo ago
    To be honest Copilot really stinks and is really far from the sharp edge of what is possible these days.
    • illwrks 5mo ago
      100%, have to use it for work though!
• geon 5mo ago
  How is this not obvious to everyone? It's like people forgot how to engineer.
• deleted 5mo ago
  [deleted]
• rglover 5mo ago
  > Babysitter: Keep a human in the loop to catch errors before they propagate. This is the only way to guarantee AI usage doesn't burn you. Any automation beyond this is just theater, no matter how much that hurts to hear/undermines your business model. A bird sings, a duck quacks. You don't expect the duck to start singing now, do you?
  • kelseyfrog 5mo ago
    I'm not sure I agree. Like all stochastic processes, LLM errors can be quantified. That makes each use case a risk-reward tradeoff where users can decide if the tradeoff makes sense for them or not. There are scenarios where errors are acceptable because the risks are low or errors are acceptable or the rewards make up for them. This is a process engineer problem where business and technology specifics matter.
    • rglover 5mo ago
      I see where you're coming from, but this assumes good behavior and discipline which most people/teams struggle with. If a business can get away with some margin of error being acceptable, more power to them. But if not (or doing so would cause additional problems; what I'd imagine to be true for a non-trivial number of orgs), it's wise to consider the nature of the tool a lot of people are suggesting is mandatory if you're dependent on consistent, predictable results.
      • kelseyfrog 5mo ago
        That's fair. A heuristic that leaves some opportunity on the table due to org capability is a reasonable one to have.
  • alasano 5mo ago
    I think babysitting LLMs is exactly the thing that burns you. Presuming you meant burns you out though.
    • 5mo ago
• deleted 5mo ago
  [deleted]
• empath75 5mo ago
  I have heard this sort of thing a lot from people working with agents, and I just think it's fundamentally misguided as a way to think of them, and if you work with them this way, you are probably setting money on fire for no reason because the tasks you are able to perform this way _don't need agents to begin with_. You might use an LLM api call here as a translation or summary step in a deterministic workflow, but they are not acting as agents, because they lack _agency_. The value of using an agent harness is precisely that they are _not deterministic_. You provide agents a goal, tools and constraints and they do the task they were asked to perform as best as they can figure out how to do it. You may provide them deterministic workflows as tools they can call, but those workflows, outside of the agent harness itself, should not constrain what the agent does. You are paying a lot of money for agent reasoning, not to act as an expensive data transformation pipeline. It may be the case that a lot of agentic workflows are more properly done with fully deterministic workflows, but the goal there should be to _remove the agents entirely_ and spend those tokens on non deterministic tasks that require agentic decision making. I do think there are fundamental limits to what agents are capable of doing unsupervised and there does need to be a lot more human guidance, observability and control over what they are doing, but that's sort of the opposite of embedding them in deterministic workflows, that is more of team integration/communication problem to solve.
• sudosteph 5mo ago
  This is a good discussion topic. A lot of people really seem to believe that if you word a prompt just so, that you just need to throw a high-powered model at it, it will work consistently how you want. And maybe as models progress that might be the case. But right now, that's not how I've seen real life work out. Even skills are not a catch-all, because besides the supply chain risk from using skills you pull from someone else, a lot of tasks require an assortment of skills. I've accommodated this with my agent team (mostly sonnets fwiw) by developing what we call "operational reflexes". Basically common tasks that require multiple domains of expertise are given a lockfile defining which of the skills are most relevant (even which fragment of a skill) and how in-depth / verbose each element needs to be to accomplish the same task the same way, with minimal hallucinations or external sources. A coordinator agent assigns the tasks and selects the relevant lockfile and sends it along or passes it along to another agent with a different specified lockfile geared towards reviewing. It's a bit, but this workflow dramatically increased the quality of output for technical work I get from my agents and I don't really need to write many prompts myself like this.
• deleted 5mo ago
  [deleted]
• hajekt2 5mo ago
  [dead]
• hmaxdml 5mo ago
  We've found that durable workflows is a much needed primitive for agents control flow. They give a structure for deterministic replays, observability, and, of course, fault tolerance, that operators need to make the agent loop reliable.
• zby 5mo ago
  I concur - it does not make sense to do in llm prompts what can be done in code. Code is cheaper, faster, deterministic and we have lots of experience with working with code. Especially all bookkeeping logic should move into the symbolic layer: https://zby.github.io/commonplace/notes/scheduler-llm-separation-exploits-an-error-correction-asymmetry/ https://zby.github.io/commonplace/notes/scheduler-llm-separa...
• ltbarcly3 5mo ago
  Don't listen to anyone who knows what should be done without proof. If someone 'knows' what agents 'need' then that knowledge is worth millions of dollars right now. If they haven't built it they are probably just talking shit.
• cesarvarela 5mo ago
  This will remain a persistent problem without a definitive answer until models move from generative tools to actual AI.
• arbirk 5mo ago
  I always wonder with these posts: - are they talking about coding (where I am the control flow) - or RPA agents (in which it is obvious) ? - also don't use llm for deterministic tasks
• 827a 5mo ago
  1000% agree. I am increasingly hesitant to believe Anthropic's continual war drum of "build for the capabilities of future models, they'll get better". We've got a QA agent that needs to run through, say, 200 markdown files of requirements in a browser session. Its a cool system that has really helped improve our team's efficiency. For the longest time we tried everything to get a prompt like the following working: "Look in this directory at the requirements files. For each requirement file, create a todo list item to determine if the application meets the requirements outlined in that file". In other words: Letting the model manage the high level control flow. This started breaking down after ~30 files. Sometimes it would miss a file. Sometimes it would triple-test a bundle of files and take 10 minutes instead of 3. An error in one file would convince it it needs to re-test four previous files, for no reason. It was very frustrating. We quickly discovered during testing that there was no consistency to its (Opus 4.6 and GPT 5.4 IIRC) ability to actually orchestrate the workflow. Sometimes it would work, sometimes it wouldn't. I've also tested it once or twice against Opus 4.7 and GPT 5.5; not as extensively; but seems to have the same problems. We ended up creating a super basic deterministic harness around the model. For each test case, trigger the model to test that test case, store results in an array, write results to file. This has made the system a billion times more reliable. But, its also made the agent impossible to run on any managed agent platform (Cursor Cloud Agents, Anthropic, etc) because they're all so gigapilled on "the agent has to run everything" that they can't see how valuable these systems can be if you just add a wee bit of determinism to them at the right place.
  • pishpash 5mo ago
    Can you not have it write your harness for you, or have it be the first step? You can push your own determinism where you need, surely.
    • svachalek 5mo ago
      True. The prompt reads: Run the following Python: ```
  • sroussey 5mo ago
    I’m working on a hybrid system of old school task graph and ai agents and let them instantiate each other. I think others will do that eventually.
• jarboot 5mo ago
  I think this is a good usecase for temporal + pydantic-ai
• mnalley95 5mo ago
  Own your control flow! A key point from 12 factor agents. "One thing that I have seen in the wild quite a bit is taking the agent pattern and sprinkling it into a broader more deterministic DAG." - https://github.com/humanlayer/12-factor-agents/blob/main/README.md#12-factor-agents https://github.com/humanlayer/12-factor-agents/blob/main/REA...
• Nizoss 5mo ago
  If you’re interested in such deterministic scaffolding/control flow, check out Probity. I created it to address this exact issue. It is a vendor-neutral ESLint-style policy engine and currently supports Claude Code, Codex, and Copilot. It uses the agents hooks payloads and session history to enforce the policies. Allowing it to be setup to block commits if a file has been modified since the checks were last run, disallow content or commands using string or regex matching, and enforce TDD without the need of any extra reporter setup and it works with any language. Feedback welcome: https://github.com/nizos/probity https://github.com/nizos/probity
• terminalbraid 5mo ago
  My friend, you have invented management.
  • Nizoss 5mo ago
    Not throwing shade at anyone here but the thought has definitely crossed my mind that we are recreating SAFe but for agents when looking at some of the orchestration setups out there. I think that it is better to not force the same hierarchical processes that worked for humans in large organizations onto agents and instead look at what they need to give better results and what their failure modes look like.
• try-working 5mo ago
  that's why you need a recursive workflow that creates its own artifacts per step that can later be used for verification.
  • Nizoss 5mo ago
    Sounds interesting, can you elaborate on your thinking? Got me curious.
    • try-working 5mo ago
      how do you verify the work that was just done in the current stage? verify against the output artifacts from the previous stages. for example, if you have a requirement doc, then you can analyse the codebase for current state, and store as a doc. then generate the implementation plan based on the delta between requirements and current state. after implementation, create an implementation summary doc. to verify the implementation in the next stage, compare the implementation summary against the implementation plan, the previous codebase analysis and the original requirements doc, as well as codebase diffs. so, every stage outputs a source of truth for that stage, which can be used by later stages for verification, alone or together with other artifacts. if you want to read more, here's the recursive-mode development workflow I built: https://recursive-mode.dev/introduction https://recursive-mode.dev/introduction
    • nhectropic 5mo ago
      [dead]
• colek42 5mo ago
  We built https://aflock.ai/ https://aflock.ai/ (open source) to help with this. Constraining activity tends to work well
• deleted 5mo ago
  [deleted]
• deleted 5mo ago
  [deleted]
• glasner 5mo ago
  This exactly why I’m building aiki to be a control layer for harness execution. I don’t think the model companies will ever give us the neutral layer we need.
• pschw 5mo ago
  [dead]
• mhotchen 5mo ago
  HUMANS need control flow. It's a very effective strategy that has worked wonders in healthcare
  • stonewizard 5mo ago
    [dead]
• 2001zhaozhao 5mo ago
  If we need control flows, then designing these control flows ought to be the future of agent engineering
• fredcallagan 5mo ago
  [flagged]
• moconnor 5mo ago
  “Flow” moves agents through a yaml flowchart of prompts and decisions. It’s working quite well for a couple of us in Tenstorrent, more to discover here though: https://github.com/yieldthought/flow https://github.com/yieldthought/flow Happily, 5.5 is good at writing and using it.
  • aryehof 5mo ago
    I find Flow really interesting, thanks for pointing it out. Deterministic workflows using AI to help perform those steps not requiring human input has been an area of interest for me for some time. Particularly interesting how you are using the AI to determine what a step has achieved and the action of the next step. Combine it with workflow elements that does handle human steps together with a notification/routing/task system would make for a helpful system for so many.
• gck1 5mo ago
  As someone who went full circle prompt-enforcement > deterministic flow > prompt-enforcement, I disagree. The reason why "DO NOT SKIP" fails is because your agent is responsible for too many things and there's things in context that are taking away the attention from this guidance. But nobody said the agent that does enforcement must be the same agent that builds. While you can likely encode some smart decision making logic in your deterministic control flow, you either make it too rigid to work well, or you'll make it so complex that at that point, you might as well just use the agent, it will be cheaper to setup and maintain. You essentially need 3 base agents: - Supervisor that manages the loop and kicks right things into gear if things break down - Orchestrator that delegates things to appropriate agents and enforces guardrails where appropriate - Workers that execute units of work. These may take many shapes.
  • ex-aws-dude 5mo ago
    Exactly, just keep adding more agents
    • SrslyJosh 5mo ago
      I can't tell if this is satire or not. Well done!
      • dnnddidiej 5mo ago
        It a heisenberg satire because more agents going wild is indeed horrible but agents restricting and counterbalancing each other can be useful (token cost ignored!).
  • baxtr 5mo ago
    I think the key question is: How can you be sure the supervisor/orchestrator agents are reliable? You are just pushing the complexity down into another layer.
    • dnnddidiej 5mo ago
      You can't be sure but the point is you can be more sure, since agent 2 ("agent" which is really just a fancy way of saying some code that calls anthropics api) has only the context to look for a violation of a single rule.
• deleted 5mo ago
  [deleted]
• zekenie 5mo ago
  you know it really depends on what you're trying to accomplish and if it's possible to describe it with deterministic control flow
• pinfloyd 5mo ago
  [dead]
• mohamedkoubaa 5mo ago
  Eventually we'll all come to the inevitable conclusion that for a task to be fully automated there should be neither human nor genie in the loop.
• rbren 5mo ago
  If you're interested in driving coding agents with code, check out the OpenHands Software Agent SDK [1] We need to define agents in code, and drive them through semi-deterministic workflows. Kick subtasks off to agents where appropriate, but do things like gather context and deal with agent output deterministically. This is a massive boost in accuracy, cost efficiency, AND speed. Stop using tokens to do the deterministic parts of the task! [1] https://github.com/OpenHands/software-agent-sdk https://github.com/OpenHands/software-agent-sdk
  • zapataband1 5mo ago
    "conversation.send_message("Write 3 facts about the current project into FACTS.txt.")" why tf would i ever need this
• Cart0ne 5mo ago
  [flagged]
• ubj 5mo ago
  I've said this before, but it's interesting to see momentum go back and forth between the flexibility and ease of everyday language, and the formal rigor of programming languages. It feels like we are still discovering the optimal operating range on a spectrum between these two domains. Perhaps the optimal range will depend on the specific field in question.
  • deleted 5mo ago
    [deleted]
• graphememes 5mo ago
  > If you’ve ever resorted to MANDATORY or DO NOT SKIP, you’ve hit the ceiling of prompting. using this is going to do the opposite of what you want
• schipperai 5mo ago
  [flagged]
• socketcluster 5mo ago
  That's why I built https://saasufy.com/ https://saasufy.com/ as an agent tool for building data-driven realtime apps. I started working on it piece by piece about 14 years ago. It was originally targeted at junior developers to provide them the necessary security and scalability guardrails whilst trying to maintain as much flexibility as possible. It's very flexible; most of Saasufy is itself is built using Saasufy. Only the actual user service and orchestration is custom backend code. Also, I designed it in a way that it would help the user fast-track their learning of important concepts like authentication, access control, schema validation. It turns out that all of these things that junior devs need are exactly what LLMs need as well. I tested it with Claude Code originally and got consistently great results. More recently, I tested with https://pi.dev https://pi.dev with GPT 5.5 and it seemed to be on par.
• moron4hire 5mo ago
  I've been building this at work. It's... shockingly not hard. People have been telling me, "get into agentic coding now or you'll get left behind" and the things they are saying need training and taste and expertise to figure out how to cajole the AI into doing a job are things that I can just write a program to do. There's this guy at work who is kind of precious about Claude Code. When Hegseth banned Anthropic, this guy freaked out. He spent many pages ranting about how terrible Gemini and Codex are and basically nuked his project. He insisted only Claude could do his project. Meanwhile, I managed to redo his work with GPT 4o in a weekend. No AI generated code anywhere, just being capable of writing a for-loop over a directory of files my own self. The AI part is only really necessary because folks can't be bothered to author documents with proper hierarchies. People talk about "AI is going to eliminate boilerplate and accelerate development and we'll do new jobs that were too costly before". Yet this guy spent weeks coaxing Claude to do something that took me a few hours because "boilerplate" is really not that big of a deal. If this is the kind of job we're going to be able to do because the value-to-effort ratio was less than 1, it kind of indicates to me that there isn't a lot of value to gain at any level of effort. Yeah, it's not really worth your time to bend over and pick up a penny, but even if I had a magical penny snagging magnet, I'm still going to ignore the pennies because that's just how valueless pennies are. If AI lets me never have to open a PowerPoint from a client to read the chart values from the piechart they screenshot and pasted into PowerPoint, that's wonderful. What more would I ever need? The rest of the work just isn't that hard. But if you think AI is going to replace people like me because it can do "boilerplate", the AI is not anywhere near as fast or cheap at getting to a reliable, consistent, repeatable process as a human for that.
• niyikiza 5mo ago
  My analogy[1] has been that we need a valet key: capped speed, geofenced, short ttl, can't open trunk/glovebox, etc. That way we don't have to say pretty please to the valet and hope that they won't get ideas. [1] https://niyikiza.com/posts/capability-delegation/ https://niyikiza.com/posts/capability-delegation/
• pron 5mo ago
  How do you have "aggressive error detection" when one of the most common and pernicious mistakes agents make are architectural? The behaviour is fine, but the code is overly defensive, hiding possible bugs and invariant violations, leading to ever more layers of complexity that ultimately end up diverging when nothing can be changed without breaking something.
• idivett 5mo ago
  Isn't that what they call "Harness engineering"?
• shouvik12 5mo ago
  [flagged]
• Amber-chen 5mo ago
  [flagged]
• noborutakahashi 5mo ago
  [flagged]
• SrslyJosh 5mo ago
  > "Agents need control flow, not more prompts" Can't wait for ya'll to come full circle and invent programming from first principles.
• cookiengineer 5mo ago
  We have control flow. It's requirements specifications and test driven development. You just have to enforce it, so the agents cannot cheat their way around it. I decided to build my agentic environment differently. Local only, sandboxed, enforced with Go specific requirement definitions that different agent roles cannot break as a contract. That alone is far better than any hyped markdown-storage-sold-as-memory project I've seen in the last weeks. Currently I am experimenting with skills tailored to other languages, because agentskills actually are kinda useless because they're not enforced nor can any of their metadata be used to predictably verify their behaviors. My recommendation to others is: Treat LLM output as malware. Analyse its behavior, not its code. Never let LLMs work outside your sandbox. Force them to not being able to escape sandboxes. And that includes removing the Bash tool, for example, because that's not a reproducible sandbox. Also, choose a language that comes with a strong unit testing methodology. I chose Go because it allows me to write unit tests for my tools, and even agents to agents communication down the line (with some limitations due to TestMain, but at least it's possible). If you write your agent environment or harness in Typescript, you already failed before you started. Compiled code isn't typesafe because the compiler doesn't generate type checks in the resulting JS code. Anyways, my two cents from the purpleteaming perspective that tries to make LLMs as deterministic as possible.
• carterschonwald 5mo ago
  i mean of course. ive been working on this the past few months and ive a bunch of tech towards this in flight, including some harness forks to layer my ideas in. eg my oh punkin pi test bed on my github.com/cartazio page , theres some shockingly obvious ince you see it tricks that i think i can stack into a really nice harness product for just doing hard real work with these models more easily
• astra_omnia 5mo ago
  I think this also points to what needs to exist after the control-flow layer. Once an agent executes a bounded workflow, teams still need a reviewable object showing what authority/scope it had, what artifacts it touched, what validation ran, what evidence was retained, and what limitations remain. Logs are useful, but they are not the same thing as an action receipt.
• marvinified 5mo ago
  Depends on the use case
• plumbline 5mo ago
  I've been thinking about this a lot actually. It can almost be related to the conversation about specialization. The more specialized a model is required to be, the less capable it seems to be at a foundational level, where as if you just aim towards a liiitle bit of abstraction, you might get the best of both worlds. Here's a pretty specific example of what I mean, but maybe food for thought: Podcast (20 minute digest): https://pub-6333550e348d4a5abe6f40ae47d2925c.r2.dev/EP008.html https://pub-6333550e348d4a5abe6f40ae47d2925c.r2.dev/EP008.ht... Paper: https://arxiv.org/abs/2605.00225 https://arxiv.org/abs/2605.00225
• dirtbag__dad 5mo ago
  Build CLIs your agents call, that scaffold what you want, and lint so it actually does achieves your intended design. Markdown files are a good reference but they are a weak enforcement tool and go stale easily. Avoid burying yourself in more skills docs you’re not even writing yourself and probably never even read. Focus that toward deterministic tooling. (Not that skills or prompts are bad, I agree a meta skill that tells an agent what subagents and what order to run is useful)
  • zapataband1 5mo ago
    lol so write an actual deterministic program? we're close to full circle
    • noisy_boy 5mo ago
      Yes but with the "judgement" to call them. If you put "review the results based on conditions described here and anything else suspicious you may spot before call the <next_deterministic_program>", it should be able to catch some case you didn't think about in your standard checks. Of course it may miss out on those or have false positives but that is the nature of the beast, as it is now.
• throwthrowuknow 5mo ago
  Isn’t this basically what Palantir does?
• ncrmro 5mo ago
  deepwork.md is made for this.
  • nhectropic 5mo ago
    [dead]
• alasano 5mo ago
  I'm building a robust runtime for this. It's externally orchestrated and managed, not by an agent running the the loop. The goal is to force LLMs to produce exactly what you want every time. I will be open sourcing soon. You can use whatever harness or tools you already use, you just delegate the actual implementation to the engine. https://engine.build https://engine.build
• piyh 5mo ago
  9 different frameworks being pushed in the comments of this thread. 2026 truly is the year of agents.
  • yangbiaogaoshou 5mo ago
    which 9 frameworks?
• pevansgreenwood 5mo ago
  [dead]
• MagicMoonlight 5mo ago
  This is slop generated right?
• nickstinemates 5mo ago
  This is why we built swamp[1]. Swamp teaches your Agent to build and execute repeatable workflows, makes all the data they produce searchable, and enables your team to collaborate. We also build swamp and swamp club using swamp. You can see that process in the lab[2]. This combines all of the creativity of the LLM for the parts that matter, while providing deterministic outcomes for the parts you need to be deterministic. 1: https://swamp.club https://swamp.club 2: https://swamp.club/lab https://swamp.club/lab
• sbinnee 5mo ago
  I have been telling this to my team that 1000 lines of instructions are deemed to fail no matter how great of instruction following capability of a model. I have been reviewing hundreds of line changes daily basis for about a month. I couldn’t help becoming a prayer.
• andai 5mo ago
  Yeah, you could also see this in 2023 with Auto-GPT. People were letting GPT "drive" when what they actually needed, in most cases, was like ten lines of Python (and maybe a few calls to a llm() function). The alternative is running your ten lines of Python in the most expensive, slowest, least reliable way possible. (Sure is popular though) For example, most people were using the agents for internet research. It would spin for hours, get distracted or forget what it was supposed to be doing. Meanwhile `import duckduckgo` and `import llm` and you can write ten lines that does the same thing in 20 seconds, actually runs deterministically, and costs 50x less. The current models are much better -- good enough that the Auto-GPT is real now! -- but running poorly specified control flow in the most expensive way possible is still a bad idea.
• allynjalford 5mo ago
  Totally agree. That's why i built it. https://backpac.xyz/cairn-cli https://backpac.xyz/cairn-cli
• nicktaobo 5mo ago
  [flagged]
• rickysahu 5mo ago
  we work on this issue in healthcare (genhealth.ai) where it's imperative to get every step correct. not easy. a valuable solution at the intersection of browser, code, lmms. there r far more layers of browser interaction than just imgs and dom.
• bandrami 5mo ago
  It's going to be hilarious in a few years when people are still using LLMs but only via a controlled vocabulary and syntax that you have to learn. It's just like how everybody moved to NoSQL 15 years ago but immediately recreated schemae in their JSON.
• k__ 5mo ago
  At my new job, I was assigned to improve processes with AI. My first thought was, well agents seem nice, but I think, AI workflows are a better bet. However, I don't really understood AI or agents in depth and felt like I was just "doing things the old way" and removing flexibility from agents was a ridiculous idea. After some research I got the impression that I was right. A well defined workflow and scope is just what's needed for AI. It's cheaper and more consistent. It probably even makes the whole thing run well with non-SOTA models.
• est 5mo ago
  I have a question, does LLM follow these MANDATORY or DO NOT SKIP during pre-train, like how people write a comment paragraph on reddit corpus, or is it just some post-train alignment habbit?
  • stingraycharles 5mo ago
    Instruction following is a specific fine tuning / post training phase, yes. That’s why you see “base” vs “instruct” models for example — base is just that, the basic language model that models language, but doesn’t follow instructions yet. Especially the open weights models have lots of variants, eg tuned for math, tuned for code, tuned for deep thinking, etc. But it’s definitely a post train thing, usually done by generating synthetic data using other models.
• sidcool 5mo ago
  How does one achieve this?
  • philipp-gayret 5mo ago
    Native integrations with agents, i.e. Claude Code's system of Hooks. Harnesses, which kick off agents with what to do. Tools, which show an agent where in a process it is, and what the next step should be. In my experience I find Hooks to be extremely powerful cross-project. CLI Tools are easy to make also, and work really well for guiding agents.
    • sidcool 5mo ago
      Thanks. Any tutorials?
      • philipp-gayret 5mo ago
        For Hooks (IMO the most powerful feature) Id recommend only https://code.claude.com/docs/en/hooks-guide https://code.claude.com/docs/en/hooks-guide and for Plugins, Skills, MCP and so on the official documentation by Anthropic has been the source you'd need. As for harnesses and CLI tools Id go with whatever you're already familiar with, can't make a particular recommendation.
• Weryj 5mo ago
  Pure agentic loops with markdown documents as a program 'agentic workflow' is incredible for experimentation, developing and testing your workflow idea. The second it works, bake the workflow into the harness. Yesterday I was doing just that, and the whole agent loop disappeared because the process could've been condensed into a one-shot request (+1 MorphLLM fast apply) from careful context construction. (It was an Autoresearcher)
• dkersten 5mo ago
  This is something I realised late last year while using Claude Code. The LLM shouldn't be the one in control of the workflow, because the LLM can make mistakes, skip steps, hallucinate steps, etc. Its also wasteful of tokens. I'm a firm believer that a "thin harness" is the wrong approach for this reason and that workflows should be enforced in code. Doing that allows you to make sure that the workflow is always followed and reduces tokens since the LLM no longer has to consider the workflow or read the workflow instructions. But it also allows more interesting things: you can split plans into steps and feed them through a workflow one by one (so the model no longer needs to have as strong multi-step following); you can give each workflow stage its own context or prompts; you can add workflow-stage-specific verification. Based on my experience with Claude Code and Kilo Code, I've been building a workflow engine for this exact purpose: it lets you define sequences, branches, and loops in a configuration file that it then steps through. I've opted to passing JSON data between stages and using the `jq` language for logic and data extraction. The engine itself is written in (hand coded; the recent Claude Code bugs taught me that the core has to be solid) Rust, while the actual LLM calls are done in a subprocess (currently I have my own Typescript+Vercel AI SDK based harness, but the plan is to support third party ones like claude code cli, codex cli, etc too in order to be able to use their subscriptions). I'm not quite ready to share it just yet, but I thought it was interesting to mention since it aims to solve the exact problem that OP is talking about.
  • user34283 5mo ago
    I‘ve recently started to use skills and so far it’s been working great. Your agent can write a python script to loop and simply call „claude -p“ or „codex exec“. For simple workflows this seems good enough and can be set up in 10 minutes without third party software. What do you think?
    • dkersten 5mo ago
      For simple workflows or once-off workflows, that's a good approach. For long running repeatable workflows (eg you want to leave your agent running over night, you want to run the same workflows over and over in different projects, or more autonomous Devin-like workflows) or you want audit trails/observability, vetted workflows (ie not have the LLM write them; or have the LLM write them and you review them) without having to read through scripts, or you have more complex requirements like having different models/providers for different workflow stages or the things I mentioned previously (context, plans, verification, etc), or you have more complex workflow needs (swarms or fork/join, parallel pipelines, routing/branching, error recovery or routing, etc) then a robust dedicated workflow engine is needed in my personal opinion. I think for most users using claude/codex for themselves on smallish projects, its unnecessary, but was you scale up, I feel that more powerful tools are needed. Also, for corporate, where you need repeatable workflows with audit trails, artefact management, and job queue based task management starts becoming more important too. I also feel that using a workflow engine as an internal behind-the-scenes system in a GUI-centric vibe coding tool might also help raise the ceiling compared to the existing tools, but I've yet to test that hypothesis. Just because it takes the mistakes out of the users hands: the engine will follow proven workflows, whether you ask it to or not, keeping skills for context/knowledge, not for orchestration. Something else I've been experimenting with a little, but not enough yet to have an opinion, is small language models running locally for orchestration, and frontier models for doing work.
• ares623 5mo ago
  Guys, c'mon, what are we even doing...
• trolleski 5mo ago
  Maybe we could devise a language which would be like a natural language but have some pretty neat formal properties... Wait...
• shivnathtathe 5mo ago
  Observability is the missing piece here — built opensmith for exactly this reason, tracing agent control flow locally
• mpaiello 5mo ago
  [dead]
• Amber-chen 5mo ago
  [flagged]
• Imanari 5mo ago
  As with so many things aider.chat was ahead of its time with its ability to create deterministic scripts.
• throawayonthe 5mo ago
  i gave in and bought a month of claude (it really is a slot machine don't do it if you have an addictive personality lol) to vibecode a bit, and the Superpowers skill set is cool and all but it really seems like something that should be turned into a program hmmmmmm maybe i could vibecode a harness based on that pi thing i've heard about, and integrate it closer with jj instead of relying on llms knowing how to use it, and make certain stages guaranteed to run... oh dear edit: also i can't bring myself to believe the 'ultimate' form or whatever stabilizes out will be chat-based interfaces for coding and code generation i think it's just that openai happened to strike gold with ChatGPT and nobody has time to figure anything else out because they've got to get the bazillion investor dollars with something that happens to kinda work also afaiu all these instruct models are based on 'base' models that 'just' do text prediction, without replying with a chat format; will we see code generation models that output just code without the chat stuff?
• cloaky233 5mo ago
  It's not that agents don't need more prompts, actually breaking the prompt into a dynamically changing prompt and a static prompt combination does resolve most of the issues. Control flow on the other hand is harnessing + context building, which is one major part of agentic workflows. So I believe a "optimized" combination of both is what we should be looking for.
• beshrkayali 5mo ago
  Humble mention, I’ve been thinking the same thing with Ossature for the last couple of months since I started working on it: https://ossature.dev https://ossature.dev The models are already good enough for code generation. What we need is the harness around them actually deterministically enforcing a specific path and “leashing” the models output to be aligned with the intention of the user as much as possible. You can’t make the output of the model deterministic, but you can make everything around it to be so. Trying to make enforcements work with prompts is like a government agency investigating/auditing itself, there’s no incentive to find problems, so you’ll always inevitably get the “All Good, Boss!”
  • toasty228 5mo ago
    > so you’ll always inevitably get the “All Good, Boss!” Or the opposite depending on how you ask the questions, some automated code review tools _always_ find issues, even when they don't really exist, or they exist in the scope of a function but not once the function is wired in the project.
• TodorGrudev 5mo ago
  [flagged]
• Ozzie-D 5mo ago
  [flagged]
• zingar 5mo ago
  This is a refreshing take but I’d really have liked an example for contrast.
• lacymorrow 5mo ago
  [flagged]
• vitlyoshin 5mo ago
  This feels right. Once an agent touches a real business workflow, prompts become only one layer. Reliability comes from state, validation, observability, and explicit failure handling.
• lydionfinance 5mo ago
  [flagged]
• coltmcnealy 5mo ago
  [dead]
• morpheos137 5mo ago
  It speaks to how dumbed down the human userbase has become that these kind of articles are even presented as insightful. "Agents" are not intelligent. they are pattern extrapolators. If you want a reliable deterministic output you need a deterministic harness. Think of agents as a montecarlo sampling tool. The harness defines the result over noise. it is hilarious to me the industry is going head long into more "intelligent" agents while ignoring that intelligence is an adaptation to constraints not some magical abstract general thing that just appears and can do useful work. AGI is a lie. Stocastic parrots + harness is a useful tool.
• pedroneto3 5mo ago
  agreed, but I don't thinkg it gonna happen without the own IA help. People only think in earning and by this, we need a not-human vision
• pjmlp 5mo ago
  Which is exactly what tools like n8n, langflow, opal, workato and many other offer. Did the author miss up on them?
• juanre 5mo ago
  Absolutely agree. However, if you do not need absolute reliability pairs of agents are much better than single agents. These days I always have one agent coding and another code-reviewing. The code reviewer is also the holder of the lamp, keeping track of the final goal. This is applicable to whatever task you want your agents to achieve: one works, the other looks over the shoulder.
• danieljhkim 5mo ago
  Sharing something that I am building right now for this: - https://github.com/danieljhkim/orbit https://github.com/danieljhkim/orbit - https://orbit-cli.com/ https://orbit-cli.com/ Any feedbacks are welcome
• BrightGirl 5mo ago
  [dead]
• maxothex 5mo ago
  [flagged]
• hiroto_lemon 5mo ago
  [flagged]
• EGreg 5mo ago
  Seems more and more people are coming to the same realization: https://community.safebots.ai/t/prominent-people-come-to-the-same-realizatiox-the-world-needs-safebox-safebots/45 https://community.safebots.ai/t/prominent-people-come-to-the...
• danborn26 5mo ago
  Relying on prompt engineering for logic is incredibly fragile. Explicit state machines and programmatic routing provide the predictability that complex agents actually require.
• nhectropic 5mo ago
  [dead]
• arbayi 5mo ago
  [dead]
• hombre_fatal 5mo ago
  That this gets so much traction is an insight into the lack of process the average HNer is using while they say they can't get LLMs to do anything useful for them. Turns out it really was just them expecting one-shots in Claude Code with "make no mistakes pls". Something to keep in mind when listening to LLM discourse on HN.
• noashavit 5mo ago
  100% Agents need reliable state management, conditional logic, and structured execution paths. Prompt engineering is a surface layer solution to a deeper problem
• naturalintell 5mo ago
  [dead]
• kristianp 5mo ago
  I have some notes for a blog along the same lines, called "Determinism vs Agents". I had the same experience with MANDATORY. Agents are also very slow compared to code. By the time it takes for the agent to ingest the system prompt + your prompt then to send a tool call to search for files in your repo, then another call to find a few patterns in those files, 30 seconds or more have passed. A non-agentic harness like Aider does that step a lot faster. Then it always does checkin of its changes. It doesn't have the flexibility to also run specific commands like code coverage checks from example. Something in between Claude Code and Aider would be useful.
• mf_kevintruong 5mo ago
  Correct, that we we should need something like DAG , kanban flow for control agent , there are deterministic combine with undeterministic the control flow need to be bind with undeterministic agent to keep thing strict but need to flexible enough
• srid 5mo ago
  I created https://agency.srid.ca/ https://agency.srid.ca/ to achieve some of this but from within a single agent CLI session Here's a recent PR created end-to-end using `/do` workflow of agency: https://github.com/srid/emanote/pull/719 https://github.com/srid/emanote/pull/719
• cadamsdotcom 5mo ago
  Yep. Deterministic shell around the powerful abilities of the model. Define what a good job looks like, unskippable steps, etc etc - essentially what your process is for producing your desired output in a reproducible way. Then codify it. Have the model write code and wrap the model in a harness that ensures said code runs when you need it to, every time.
• theuniverseson 5mo ago
  [flagged]
• venturin 5mo ago
  Strong agreement on the thesis. The piece is most useful for naming what's bankrupt about prompt chains. Where it stops short is what the verification checkpoints should actually verify. One way to slice it: there are three kinds of underspecification an agent has to close. Intent: what the user wanted (JWT vs cookies, should free users see this feature). Verification can't close this and probably shouldn't try. Structural e.g. null, types, exhaustiveness, ownership. Sound static analysis closes this by construction. Domain e.g. auth on every route, error propagation, contract stability. A domain-shaped apparatus closes this because it knows what kind of program is being built. Babysitter, auditor, prayer is the right taxonomy of bad options. The fourth option is making the LLM a component inside an apparatus that handles structural and domain statically, and leaving the human on intent.