Your company needs an outer loop
Everyone is racing to put agents in loops. A loop is only as good as the information it grounds itself in, and most companies have let that information fall behind a horizon they can't reach.
Making use of your organization’s context is hard. Dorsey was onto something in his blog “From Hierarchy to Intelligence” Jack Dorsey and Roelof Botha, From Hierarchy to Intelligence. The case that an org’s context is a vastly underrated lever.: an org’s context is its real operating system, and the companies of tomorrow need their own company model that holds the intelligence lever of their entire org. However, building the contextual memory layer for an organization is not as easy as throwing everything into a vector space and slapping search tools on top. That is simply a black hole where things go in but never come out. You end up with your own sorry little version of the black hole information paradox. The strange thing is that it does not destroy what falls in. The decision is still in there, past the event horizon. You just can’t pull it back out. A real memory does the opposite. It runs a loop: it notices what changed, reconciles it, and writes it back.
To exemplify this in terms of an actual piece of knowledge, let’s track the lifecycle of an organizational decision. Someone decides that we will do X to resolve a bug. This lands in multiple people’s meeting notes, with their own transcriptions describing X in different ways. Then the owner of X or the PM has to act and formalize that decision into a ticket or a document, otherwise it’ll be lost to the black hole. Finally, it lands with the engineer who actually has to build X. This is the engineer’s version, and every other org function has its own version of the same. A lot of these decisions never actually get picked up, maybe in a Slack thread, a DM, or someone’s head.
The information is not gone. It exists somewhere. There is just no good way to retrieve it, or even mutate it.
When you try to use a vector search to look for this, you get about 200 unranked messages, and that gets jammed into your agent for inference. I’m quite sure that a lot of frontier labs are often debating about naming their new models and have to go back into Slack’s terrible search to retrieve the decision they made three weeks ago. The answer is in there. The paradox is how to retrieve it.
We treat docs like archives. You write something down once, and people read it forever. When it goes stale, the only fix anyone reaches for is a mandate: a process, a quarterly review, someone whose job is to keep the wiki honest. Humans are bad at this. We skip it, and the docs rot.
The rot is often overlooked. We as humans have a gift of rational optimism, and documentation is subject to the same. We assume that having a doc is good enough, and that its lifecycle will take care of itself if we do our jobs properly. All of our tools dump into one big pile, and search tries to make sense of that via retrieval. The pile only keeps growing, without curation.
This is where the ever-present problem meets the newfound lobbying of loops. One drops a capable model into a constraint space with an evaluator and an iteration budget, it runs, checks, adjusts, runs until it achieves the goal or finds a local maximum. The hype is partly based on Karpathy’s brilliant autoresearch. Andrej Karpathy, autoresearch.
I liked Lance Martin’s take on this recently, Lance Martin, Designing loops with Fable 5. The inner-loop framing is his. especially the caveat: checking cannot come from the same context that did the work, otherwise an agent that grades itself is bound to have blind spots. You need a verifier in the loop.
In addition to this agentic “self-correction” loop, Martin goes on to describe an outer loop. The two run at different scopes and speeds. The inner loop is the fast one. It lives inside a single task: the agent runs, checks, adjusts, and keeps iterating until it reaches a version of the solution. That is the loop everyone is excited about right now. The outer loop is the slow one. It runs across sessions, and it dictates how the agent carries context, and the learnings from one task into the next.
Martin gives that outer loop a shape: fail, investigate, verify, distill, consult. You get something wrong, you dig into why, you turn that into a fact you’ve actually checked instead of guessed, it becomes a rule, and from then on you just consult the rule instead of relearning the lesson every single time. A weak agent never gets past the first step, just hoarding notes it never reopens or updates. On the other hand, a strong one follows all the steps and sets up the rules for other agents and sessions as well.
That circuit is what a company brain, memory, or context layer is supposed to handle. Going back to decision X that we mentioned earlier, someone consults the record and acts on it, it breaks or gets superseded by a newer decision, someone encounters the outdated decision, digs into why it’s there, the correction gets checked against code, meeting notes, Slack discussions, and other docs, and it gets persisted as a documented decision that is subject to auto-updates. Run that loop and your knowledge stays alive and evolves. Skip it, and decisions continue to slip past the event horizon, into the information black hole.
Any loop is only as good as the information it uses to ground the workflow. If the starting point and retrieved context are defective or outdated, then the outer loop is broken. If you put an agent’s inner loop to work off of the broken outer loop, it won’t self-correct, and in fact self-reinforces and doubles down on the wrong information more confidently than a person would. Think about a chain of agents per employee working off of this broken outer loop, and the problems start compounding exponentially.
I watch the human version of this play out constantly. A new hire reads a doc, has no reason to doubt it, and just runs with it. Their work inherits the error, and it spreads quietly and unmeasured until some senior who actually knows the code happens to catch it, if it even comes up. That senior catch was the only safety net we ever had, and it was always thin. An agent is that same new hire, except it never doubts and it runs a thousand times over. And now that everyone is token-maxxing, not even reading the commits that land in main, even that last thin check is on its way out. We are going to see more mistakes, more jank, and more quiet vulnerabilities ride that loop straight into production.
So a company’s memory is not a side quest to all the agent-loop excitement. It is the floor the whole thing stands on.
Everyone is building inner loops on an outer loop that is already broken.
The outer loop only works if contradictions and supersessions actually get caught and resolved, and getting that to a hundred percent is genuinely hard. I have been seeing some version of this problem since I started working with agentic workflows in 2023, and I still have not seen a better solution reach mass adoption. That is the problem we are chipping at. The specific workflows vary wildly between orgs, but they collapse into a handful of shapes.
What I would warn against is treating the loop as the whole prize. The black hole is real, and it pulls on every org with serious force. You can spend effort to settle into an orbit and circle it, which at least keeps you from falling in, but it is a holding pattern. The real value is the Interstellar move: getting behind the horizon, decoding it, and sending something usable back out through the gravity. That is the moment you stop being dragged around by your own accumulated information and start steering it. I am an optimist about this. We chip away, little by little, until we are the ones flying the trajectory instead of falling into it.
I work on this at Falconer, where we are building a shared memory layer for teams and their agents.