<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Leon Goldberg on Medium]]></title>
        <description><![CDATA[Stories by Leon Goldberg on Medium]]></description>
        <link>https://medium.com/@leon.otium?source=rss-5b4106242605------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*BmH72qKx3w4aypo-lk5lIQ.jpeg</url>
            <title>Stories by Leon Goldberg on Medium</title>
            <link>https://medium.com/@leon.otium?source=rss-5b4106242605------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 02:15:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@leon.otium/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Context is the Architecture: Rethinking Security Platforms in the LLM Era]]></title>
            <link>https://medium.com/sola-security/context-is-the-architecture-rethinking-security-platforms-in-the-llm-era-a70e36636787?source=rss-5b4106242605------2</link>
            <guid isPermaLink="false">https://medium.com/p/a70e36636787</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm-applications]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[context-engineering]]></category>
            <dc:creator><![CDATA[Leon Goldberg]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 06:00:36 GMT</pubDate>
            <atom:updated>2026-07-06T06:55:06.459Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WfJQxnYq7SgkERrDmXF2Zg.png" /></figure><p>A scanner flags an over-broad IAM role. The finding is accurate: the role can do far more than it should. But what it states and what you need to know are two different things. The finding tells you what is true of the role. Whether it matters here lives somewhere else. In the identity provider, the role traces back to Dana, a contractor who left months ago. In the data catalog, that role can read a bucket of customer records. The bucket turns out to be reachable. Three consoles later, an analyst has a conclusion no single tool held: a dormant contractor still has a live path to customer data. That conclusion had been sitting in a queue beside a hundred benign “role too broad” alerts that looked exactly the same.</p><p>That manual reassembly is the triage loop: pivoting across tools to decide whether a finding is a real problem or noise. Across the alert queue, it is where much of an analyst’s time goes. Closing it is the most valuable thing a security platform can do. Another detector won’t close it; it only adds a hundred-and-first alert to the same queue. The loop closes when the system does the reassembly itself, relating the role to the contractor to the bucket to the network and handing back the conclusion with its evidence. That is an architectural problem.</p><p>In this article, we’ll walk through an architecture that closes the loop in the LLM era, based on what we’ve spent the last two years building. <br>We start with the one bet made before any code: <strong>whether to surface a catalog of known problems, or connect the dots across the whole discipline</strong>. Then the three problems that bet creates.</p><ol><li><strong>Breadth</strong>: acquiring an entire estate and modeling everything across its many layers.</li><li><strong>Depth:</strong> turning that raw data into accurate intelligence, cheaply and consistently enough to keep current.</li><li><strong>Performance:</strong> reasoning over hundreds of billions of relationships the moment a question lands.</li></ol><p>And finally, what it takes to trust the result: a graph that stays coherent as its sources change and enforces who can see which edge.</p><blockquote>The finding is accurate…but it only tells you what is true of the role. Whether it matters lives somewhere else.</blockquote><h4>Context, not the model</h4><p>Andrej Karpathy popularized “context engineering” in mid-2025, and Anthropic frames it as the discipline beyond prompt engineering: curating the right tokens to put in front of a model at inference time [1]. The New Stack put it plainly: the real bottleneck in enterprise AI is not the model, it is context [2]. Even vendors bolting AI onto established security stacks describe the capability the same way [3]. We benchmarked it ourselves [8,9], and will return to it later in the article. Before LLMs, nothing could reason flexibly over the result, so you modeled the specific questions you meant to answer and built around them. Now the model raises the ceiling, and the work that decides how close you get to it lives in the context. The open question is no longer whether context is the lever, but how you wield it.</p><p>Wielding it is not the same as hoarding it. More context is not monotonically better; past a point it is actively worse. Performance on frontier models degrades as input grows, models favor what sits at the start and end of a long context over what’s buried in the middle, and even a single irrelevant document measurably hurts reasoning [4,5,6]. A bigger context window is not a bigger brain. So the goal is to gather everything and still hand the model only the right minimal slice. Every token earns its place.</p><p>Security makes the discipline acute. In software engineering the feedback loop is tight: you ship, a test passes or fails, and <strong>output is bound to outcome</strong> within minutes, or less. Security gets no such gift. A finding, an alert, a score sits a long, noisy distance from the outcome it is meant to anticipate. Most findings never become incidents, most incidents were never cleanly foretold, and the truth arrives late, partial, and contested. That gap is what the triage loop closes by hand, one finding at a time, and it is why the burden falls on context here more than almost anywhere. The how is the hard part.</p><h4>The bet: surface problems, or connect the dots</h4><p>Every security platform makes one decision before the first line of code, and everything else follows from it: what is the system for?</p><p>Most security products are built to surface a set of problems: a catalog of known misconfigurations, signatures, and policy violations, each evaluated against the facts its own policy needs. The best exposure-management and CNAPP platforms go further. They relate findings into attack paths, having understood years ago that security is a graph, and that the dangerous thing is usually a combination of conditions rather than any single finding. That is settled, and it is right. The shift that matters sits upstream of the graph, in what you decide to model.</p><blockquote>Every security platform makes one decision before the first line of code, and everything else follows from it: what is the system for?</blockquote><p>Even a platform that models the graph well usually models a bounded set of question-shapes: the ones its policies were written to evaluate. A connect-the-dots system models everything it can, so that any question is answerable, including the ones no policy anticipated like identities, cloud and infrastructure configuration, data, and network reachability. That’s because each of these bears on posture. Anyone can answer one cross-domain question by hand, given an afternoon. The <em>real</em> bar is whether the system answers them as a matter of course: can this identity reach this data store over a path that is actually open should resolve as a single join across one model, reliably, every time it’s asked?</p><p>There is a second boundary worth refusing, and it cuts against how the market talks. Everyone wants the same thing in the end: an enterprise security brain that reasons across the whole estate. That goal is exactly right. The open question is how you get there. The common assumption is that the brain gets smarter the more of one vendor’s portfolio you adopt. That is clean logic from the platform’s side, and it runs into something real on the enterprise’s side. No vendor owns the whole stack. Enterprises do not rip out the category leaders they have already bet on, in endpoint, cloud, identity, network access, to consolidate onto one. A platform whose understanding is bounded by what it has deployed is simply bounded, and ingesting another product’s findings does not lift that bound. A finding is a conclusion: a vendor’s verdict, frozen at the moment it was emitted, carrying only the evidence the vendor chose to keep. Reasoning over someone else’s conclusions is not the same as reasoning over the operating state and business context they were drawn from.</p><p>You cannot glue that brain together from portfolios and achieve optimal outcomes. It has to reason across all three at once: what the security tools conclude, the operating state beneath them, and the business context that decides which of it matters. A platform that reaches only the first has set its ceiling on the first day.</p><p>That single decision cascades into every layer: how data is acquired, how it is made intelligent, how it is retrieved, how it is kept coherent and governed. The architecture has to be built for inference, not for enumeration. And at every layer the same question recurs, the one a system built only to enumerate never has to ask: can I answer this by retrieval, or do I have to reason for it?</p><h3>Breadth: acquiring the world</h3><h4>Gathering at scale</h4><p>You cannot connect dots you never gathered, so the first cost is breadth. Breadth in security is brutal. The data lives everywhere, in every shape, and rarely under your control. This is not one hard problem but several stacked together, and the first is the shape of the cost itself. Adding a source is never a self-contained unit of work, because the value is not in the source but in how its entities relate to everything already there. Bring in a new population of identities, and each one has to be related to the roles, resources, and people you already hold. The work is many-to-many, not one-per-source. That combinatorial shape is the first reason hand-building integrations is a losing game.</p><p>Even the mechanical part is harder than it looks, and it is where many security companies quietly stall: extracting from an effectively unbounded set of systems, continuously, at scale, without drowning in maintenance. That only survives if you take the code out of onboarding. A new source should be brought in by describing it, declaratively, not by writing and maintaining a bespoke connector for every API in the world. Schema, not software. And the systems you pull from do not hold still. You control your own model; you do not control the upstream interfaces. An API breaks, deprecates a field, or changes shape the day a vendor ships a release. An authorization scope you had yesterday can be gone tomorrow. So acquisition is never a project that finishes. It is standing surveillance: watching every source for the moment it shifts out from under you, before a silent change corrupts everything downstream.</p><h4>Where the data has to live</h4><p>Where the data should live is a choice between two roads, and the honest answer is to take both. Most of it you want to bring home, consolidated where you can reason over it at full speed. But some of it is too large to move, too sensitive to copy, or bound by law to stay where it sits. For that, the only discipline-spanning option is to leave it in place and reason over it there, pulling back answers rather than data. A view that quietly drops everything inconvenient to move is not discipline-spanning at all.</p><p>Federation is also where the genuinely hard problem hides, the one most “we support your data” claims never reach. A customer’s own environment carries an ontology you did not design: a home-grown notion of a “service,” an ownership convention buried in a tag, a criticality tier or data classification that exists in no vendor’s catalog. Mapping known vendor schemas onto a model you control is the tractable part. Discovering that private ontology and folding it into the shared one, so the customer’s concepts and yours answer the same question together, is not.</p><h4>From data to meaning</h4><p>But pulling the data is only mechanics. The work that matters is making it mean something, and a source tells you almost nothing about meaning. It speaks in its own vocabulary. A row in it is just a row until the system can say what this thing is, what it represents, and what it relates to. That understanding has to be learned, not assumed. It can be inferred rather than hand-written, but inference that cheap cannot be trusted on faith, so nothing a machine proposes is believed until it earns belief, through checks that escalate from is this even well-formed to does it still hold against the live system. What you are building is a model of the source: something that explains the data on its own terms and reconciles into the single vocabulary the rest of the system speaks.</p><p>The first hard part is knowing when two records are the same thing. The same entity arrives under many names. Dana is an account in the identity provider, a mailbox in the mail system, a federated identity at an external provider, an owner: dana tag on a workload. Four records, one human. Until they collapse into a single node, a question that lives in the seam between two providers cannot even be asked.</p><p>Identity resolution like that has the clearest rules of the lot. Knowing how different things connect is the harder part: the edges, the synapses of the graph. That this identity can assume that role, that the role can read that store, that the store is reachable from that network node. These are rarely a clean foreign-key join waiting to be made. They are buried in unstructured configuration, in non-canonical representations, in conventions that differ by vendor and by resource type. An identity, a subnet, and a container do not describe themselves the same way, so the edge between them has to be inferred from how the pieces fit rather than looked up. Do that well and the modeled world is enormous. In production, ours spans more than a thousand kinds of nodes and over eleven hundred kinds of relationships, almost none of it handed to us, nearly all of it inferred.</p><p>And edges are only the first degree of it. On top of the modeled graph, the system derives intelligence that appears in no source at all: the blast radius of a resource, everything a foothold there could reach, and the attack vectors into it, the paths an adversary would actually take. Much of the security value lives in exactly these second- and third-degree questions, computed across the graph rather than read from it, and no easier to get right than the first degree.</p><p>There is no single way to build this intelligence, and there shouldn’t be. Open-source tooling, public frameworks, the security literature, and human-assisted generation are all fair game. What matters is the scoreboard: as much intelligence over the data as possible, produced as fast as possible, and right as often as possible on the first try, with people validating and correcting it so the next attempt is better. Speed here is a family of time-to-X metrics, from time-to-edge to time-to-blast-radius: how quickly a newly arrived fact becomes not a stored row but verified, usable intelligence. This understanding accumulates rather than appears. You do not build a discipline’s worth of modeled meaning in a day.</p><p>All of it is built offline, before any question is asked. Depth is where that intelligence is turned on individual resources, to say not just what could happen, but what matters here.</p><h3>Depth: turning data into intelligence</h3><h4>Contextualization</h4><p>Breadth fills the system with data. Making that data mean something is a separate job, and it is the point of everything that follows. The work has a name: contextualization. Take a resource and situate it, so that “an S3 bucket” becomes “a bucket holding customer records, readable by a dormant contractor’s role, reachable from the internet.” That is the unit of intelligence the whole system exists to produce. Everything else in depth serves to produce it well, cheaply enough to keep current, and in a form you can retrieve. In security, it has to carry the accuracy the domain demands, because a wrong context is not a rounding error. A missed privilege path is a missed incident. A phantom one is a team sent chasing a ghost, learning to distrust the tool.</p><p>Accuracy starts with order: deterministic, verifiable ground first, learned judgment only ever on top of it. That ground is not one signal but a ladder of them, each asking a sharper question than the last. An anomaly says look here: this resource stands apart from its peers. A failing control says a problem is actually present. An attack vector says it is not just present but reachable, the kind of thing an adversary could walk to. A blast radius says here is what it would cost if they did. None of these is asserted by a model. Each is read from the source of record or computed reproducibly over the graph, which is what lets everything above rest on it.</p><p>What that ladder still cannot tell you is whether any of it matters here. A perfectly exploitable path to a resource nobody depends on is noise. A smaller exposure on the system the business runs on is the alert that should have woken someone. The missing piece is semantics: what a resource is to the organization. This is where model reasoning earns its place, reading the business meaning the facts cannot carry on their own and letting it gate them rather than overrule them. So interpretation enters only as a modulation of the deterministic ground, within a deliberately narrow band. Let it run ahead of the facts and the system becomes confidently, unaccountably wrong. This is the separation between intrinsic exposure and contextual importance that we draw in our work on AI-native asset intelligence [7].</p><p>Two disciplines keep it honest. Signals that trace to one root weakness are a single exposure, not several stacked into a falsely louder one. And the same inputs have to yield the same understanding run to run, because a verdict that wobbles between runs is one nobody trusts twice.</p><h4>Doing the heavy work only where it counts</h4><p>Contextualization this rich is far too expensive to run from scratch on every resource at such breadth. There are too many of them, changing too often. The pyramid is what makes it affordable: the heavy work happens only where it is warranted, and ahead of time. The first move is clustering. Most resources are templated, one of ten thousand workloads stamped from the same mold, so the near-identical can be clustered and understood once, with each member inheriting the result.</p><p>Clustering also answers what to recompute, and when. The signal that matters is change. When the underlying data shifts, the question is whether it moved a resource out of the cluster it belonged to, and only what actually moved is recomputed. Never the whole estate on every small edit. The same clustering shows where the heavy, individual work belongs. A resource that still matches its cluster inherits an understanding already paid for. The ones that match nothing form clusters of their own and earn fresh, individual attention: the leftover nobody decommissioned, the instance configured by hand against every convention. That is disproportionately where real risk hides.</p><p>Getting that clustering right is one of the harder things the system does, because “the same” means different things on different axes, and the axes disagree. Sometimes you want sameness in the strict sense: identical configuration, identical shape, reproducible enough that the same inputs always land in the same cluster. An identity- or hash-based scheme serves that well. Other times you want likeness in meaning, where “close enough” is a matter of degree, better served by similarity in embedding space. Neither is right on its own, so the clustering works in more than one tier at once. And it has to do so agnostically: with a thousand kinds of resources and no per-type ground truth for what “the same” should mean, the system has to discover those boundaries for itself.</p><p>The dial that matters is how much disparity you absorb before two families share a single contextualization. Too loose, and a genuinely exposed resource hides inside a benign cluster that merely resembles it. Too tight, and you are back to contextualizing nearly everything from scratch. Keeping the clusters stable while the estate churns is what makes recomputing only the changes possible. If a small edit reshuffled every cluster, nothing would stay localized, and you would be re-deriving the world on every move.</p><h4>Search, and research</h4><p>All that contextualized understanding still has to be retrievable. That is the pyramid seen from the query side, a spectrum rather than two shelves. At the cheap end the work is already done and you simply retrieve it; the answer was shaped in advance. It is tempting to picture that as a pile of ranked text: ask, and get back the passage that answers you. But that is too small a picture. Many of the questions that matter are about paths, not passages. Which identities can reach this database is settled by walking edges, not ranking documents. So the curated end has to be walkable as well as searchable, and small enough, because it is curated rather than complete, to sit in an ordinary graph store and be traversed fast. As a question gets more novel, less of it has been answered in advance, and you slide toward the expensive end: multi-step reasoning, reconstruction, traversal of the full raw graph. Where a question lands depends on how much of the work that answers it has already been done. Most fall somewhere in the middle, partly precomputed, partly reasoned out on demand.</p><p>How you retrieve is itself a choice per question. Some are exact and want literal, sparse matching. Some are fuzzy and want similarity in embedding space. Some want both fused. Some are paths and want traversal. Not every point on the spectrum supports every mode, so how you prepare and embed data on the way up has to be decided around how you mean to retrieve it on the way down. Prepare it in a shape that does not fit the question, and no retrieval bolted on afterward will recover the answer. That alignment between preparation and retrieval is the first of two things that cannot be added after the fact.</p><h4>The flywheel</h4><p>Contextualization also pays a dividend that is easy to miss. Every time the system contextualizes a resource, it tends to surface relationships that were not explicit before: that this exposure reaches that asset, that these two findings share a cause. Once those pass the same validation as everything else, they are curated into the layer the next question is answered against, so it has more to reason over than the last. The better and more validated the data already is, the more the next pass can infer from it; the more it infers, the better the data becomes. Every validated turn is something a later competitor has to accumulate from scratch.</p><p>It is fragile in a specific way. A flywheel amplifies whatever you feed it, so an unvalidated guess compounds into error exactly as fast as a verified fact compounds into signal. Which is why validation is not a step you skip for speed, and not purely automatic. A learned relationship is trusted only after it is checked against deterministic ground, and, where the stakes are highest, against a person who reviews and corrects what the model proposed. An inferred path that a deny policy forbids is thrown out before it can become the silent premise of everything built on top of it.</p><p>None of this is ever finished, because the world it describes keeps moving, and curated understanding is only worth as much as it is current. That puts the weight back on the base of the system.</p><h4>Performance: a base layer that reasons</h4><p>Breadth and depth describe what the system holds and understands. Performance is what makes it usable the moment a question arrives. The demand lands hardest at the base of the pyramid, on the largest, rawest, most connected data.</p><p>The same spectrum that governs retrieval governs storage. The closest analogy is a processor’s memory hierarchy: a small amount of hot, fast memory close to the work; vast cold storage farther away; and the whole art lies in deciding what lives where.</p><p>The naive answer is to make everything hot: load all relationships into the fast tier and pay the cost. At the scale of a discipline, that is neither affordable nor possible. The more interesting move is the opposite: make the cold tier intelligent enough to participate in reasoning.</p><p>That shift is now possible because the foundations of large-scale analytics have changed. Cheap object storage is no longer just an archive. Columnar layouts, open table formats, metadata indexes, partition pruning, predicate pushdown, and vectorized execution have turned lakehouse-style storage into an active query substrate. The remaining step is not simply to run SQL over it, but to expose it in the language of the domain: relationships, paths, neighborhoods, and traversals.</p><p>In other words, the base of the pyramid should not require being loaded into a conventional graph database before it can be reasoned over. Graph databases are genuinely good, and they are exactly what belongs in the hot, curated layer near the top of the hierarchy. But the base is a different problem. There, the right abstraction is an optimized graph query engine that can execute graph-native dialects directly over the cold store, allowing Cypher-like traversal semantics over columnar, partitioned data without first materializing the entire graph into a dedicated serving database.</p><p>In our production deployment, this approach runs past 500 billion edges at sub-second average query latency on real, partition-pruned traversal workloads. That is the claim that matters: at the scale of an entire discipline, the base of the pyramid should be reasoned over, not merely stored.</p><h4>A graph you can trust</h4><p>Scale lets you reason over the graph. It does not, by itself, let you trust what you reason over. Two more properties do, and neither is about speed. Both have to be true of every edge, enforced in the substrate as the query runs, and neither can be added once the rest is built.</p><p>The first is coherence in time. Every edge and every resource carries the revision of the extraction that produced it. The naive mental model, “query the graph as of revision r,” is wrong, because there is no single revision for the whole graph. Different sources extract on different cadences, so revision lives at the granularity of individual resources and edges, and an edge is coherent only when its endpoints carry revisions that line up. Stamping a version on things is the easy part. The real work is assembling the most recent coherent snapshot, at query time and at speed, out of millions of independently-revisioned parts. The engine reads only the slices a traversal needs, pruning hard on revision so it never touches what doesn’t belong to the question. The payoff is escaping the quagmire of inconsistent state. Without coherent revisions, a traversal reads a smear of half-updated world, and the team ends up arguing over whether a finding is real or just an artifact of one source running a cycle ahead of another. It also makes a working memory feasible. With revisions to anchor it, the system keeps a coherent recent slice hot and lets the rest age into cold storage, evicting safely because nothing it serves depends on a half-updated mix.</p><p>Since the store retains immutable, time-stamped snapshots rather than overwriting in place, it also keeps what it held before. A question about the past is answered by reading a retained snapshot instead of reconstructing history by hand. (Separating when something was true in the world from when the system came to know it is subtler still. The snapshots give you the second cleanly).</p><p>The second is access, and not the basic kind. Keeping one customer’s data from another’s is table stakes, really a matter of authentication. The harder reality is that inside a single enterprise, not everyone should see everything. A viewer may be entitled to some integrations and not others, and the graph has to honor that as it reasons, not after. This is a degree harder than row-level access control. The unit you are authorizing is the edge, the synapse, not the row, and it has to hold mid-traversal rather than at the end. So an edge carries more than a revision. It carries the scope it came from. Who may traverse it is enforced as the query runs, with guards injected into the traversal before it executes, so an edge outside the viewer’s scope, or outside the coherent snapshot, is never visited and never shapes the answer. That is a different design, with a different failure mode, from scrubbing a forbidden fact out of an answer after it has already shaped everything computed along the way. Bolt analytics onto a storage tier and you get a faster archive. You get a substrate you can reason over, coherently and safely, only when these are properties of how the foundation was laid.</p><h3>Measuring what you can’t take on faith</h3><p>Everything to this point runs on model reasoning, and model reasoning is not deterministic. The capabilities here are tuned tightly to the behavior of specific models, and that behavior moves: the same question can take a different path tomorrow than it took today, and a single model upgrade can shift the ground beneath a feature that worked the day before. You are trading accuracy against efficiency, cost, and impact on every call, and none of those trades holds still. So you cannot take the system’s output on faith. The gap between output and outcome that makes security so unforgiving will not close on its own.</p><blockquote>The model was never the scarce part. The context to reason over was, and that is the part you can only build in.</blockquote><p>Engineering has long had a blunt version of this discipline: if it isn’t tested, it doesn’t exist. For capabilities fitted this closely to models that drift, the bar is higher. In context engineering, and far more so in security, if it isn’t benchmarked, it doesn’t exist. A capability you cannot measure end to end, from real data through the whole system to a verifiable answer, is one you are taking on faith, and faith is what the domain does not allow.</p><p>So the machinery of measurement is a first-class citizen of the platform, not a QA afterthought bolted on near release. The datasets, the graders, the harnesses that turn a natural-language question into executable steps and check the answer against production-grade infrastructure deserve the same engineering seriousness as the query engine or the storage layer. They are what tells you whether the rest is still working as the data and the models beneath it move. And what you measure matters as much as that you measure. Score the path, not only the answer, because a right answer reached by a brittle, extravagant route will not survive scale or change. Test across vendors rather than within one, because the question that matters usually lives in the seams between them, where single-vendor evaluation cannot see it. This is work we build, run continuously, and publish, so the method can be checked and improved on [8]. In our own cross-vendor benchmark, holding the models and task set fixed and varying only the context raised correctness while sharply cutting the agent’s exploration queries, so better-curated context proved both cheaper and more correct [9].</p><h3>You build it in, or you rebuild</h3><p>Be plain about the size of what this is. A platform that connects the dots is not a sharper point solution, and it is not a dozen point solutions wired together. It is a different kind of system, and its decisive choices are made before the first line of code. The alignment between how data is prepared and how it is retrieved; the substrate that stays coherent and governed beneath every query; the understanding that deepens with every validated pass: none of these is a module you attach later. Each was a fork in the road, taken at the start. That is why a platform built to enumerate known problems can be excellent at its job and still never close the triage loop. The work it cannot do was designed out on day one.</p><p>Pay that price up front, though, and the LLM era turns from a threat into leverage. The triage loop closes. Analysts spend their hours deciding instead of reassembling. A system that once produced alerts begins to produce understanding. The model was never the scarce part. The context to reason over was, and that is the part you can only build in.</p><p>So the real choice was never which features to buy. A point solution is something you ship. A system that reasons over an entire discipline is something you accumulate, decision by decision, edge by validated edge, year over year. Its advantage compounds the whole time, and the years are the one thing a rebuild can never give back.</p><h3>References</h3><p>[1] Anthropic, “Effective context engineering for AI agents.” <a href="https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents">https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents</a></p><p>[2] The New Stack, “The Real Bottleneck in Enterprise AI Isn’t the Model, It’s Context.” <a href="https://thenewstack.io/the-real-bottleneck-in-enterprise-ai-isnt-the-model-its-context/">https://thenewstack.io/the-real-bottleneck-in-enterprise-ai-isnt-the-model-its-context/</a></p><p>[3] Microsoft Security Blog, “Empowering defenders in the era of agentic AI with Microsoft Sentinel” (September 30, 2025). <a href="https://www.microsoft.com/en-us/security/blog/2025/09/30/empowering-defenders-in-the-era-of-agentic-ai-with-microsoft-sentinel/">https://www.microsoft.com/en-us/security/blog/2025/09/30/empowering-defenders-in-the-era-of-agentic-ai-with-microsoft-sentinel/</a></p><p>[4] K. Hong, A. Troynikov, J. Huber, “Context Rot: How Increasing Input Tokens Impacts LLM Performance,” Chroma Technical Report, July 2025. <a href="https://research.trychroma.com/context-rot">https://research.trychroma.com/context-rot</a></p><p>[5] N. F. Liu et al., “Lost in the Middle: How Language Models Use Long Contexts,” TACL 2024. <a href="https://arxiv.org/abs/2307.03172">https://arxiv.org/abs/2307.03172</a></p><p>[6] F. Shi et al., “Large Language Models Can Be Easily Distracted by Irrelevant Context,” ICML 2023. <a href="https://arxiv.org/abs/2302.00093">https://arxiv.org/abs/2302.00093</a></p><p>[7] G. Engelberg, L. Goldberg, K. Koutsyi, et al., “AI Native Asset Intelligence.” <a href="https://arxiv.org/abs/2605.09115">https://arxiv.org/abs/2605.09115</a></p><p>[8] G. Engelberg, K. Koutsyi, L. Goldberg, et al., “Sola-Visibility-ISPM: Benchmarking Agentic AI for Identity Security Posture Management Visibility.” <a href="https://arxiv.org/abs/2601.07880">https://arxiv.org/abs/2601.07880</a></p><p>[9] E. Yavin, G. Engelberg, K. Koutsyi, L. Goldberg, G. Baron, “Cross-Vendor Sola ISPM Benchmark: Evaluating Agentic AI for Federated Identity Security Reasoning.” <a href="https://arxiv.org/abs/2606.02674">https://arxiv.org/abs/2606.02674</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a70e36636787" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sola-security/context-is-the-architecture-rethinking-security-platforms-in-the-llm-era-a70e36636787">Context is the Architecture: Rethinking Security Platforms in the LLM Era</a> was originally published in <a href="https://medium.com/sola-security">Sola Security</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Visualizing CI/CD from an attacker’s perspective]]></title>
            <link>https://medium.com/cider-sec/visualizing-ci-cd-from-an-attackers-perspective-22dfa38c9d09?source=rss-5b4106242605------2</link>
            <guid isPermaLink="false">https://medium.com/p/22dfa38c9d09</guid>
            <category><![CDATA[graph-data-model]]></category>
            <category><![CDATA[devsecops]]></category>
            <category><![CDATA[ci]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[dc]]></category>
            <dc:creator><![CDATA[Leon Goldberg]]></dc:creator>
            <pubDate>Mon, 10 Jan 2022 14:03:50 GMT</pubDate>
            <atom:updated>2022-01-10T14:03:50.111Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kvu6oAH7A3665uKNSCrjdQ.png" /></figure><p><strong>Lessons learned and insight gained from a year of modeling and engineering CI/CD graphs</strong></p><p>CI/CD environments and processes are increasingly becoming a key area of focus for both hackers and — consequently — for defenders.</p><p>At <a href="https://medium.com/cider-sec">Cider Security</a>, we believe that visualizing these environments and modeling the relationships between the different objects in them is a key guiding principle for anyone interested in building the necessary capabilities to protect CI/CD ecosystems.</p><p>I decided to take the opportunity to share some insights around the elaborate task of engineering a solution that represents CI/CD in graphs, after having spent a year doing so.</p><h3>Intro</h3><p>One of our primary goals at Cider is to help organizations protect their CI/CD ecosystem.</p><p>Attackers are continuously focusing on hacking CI/CD systems. 2021 alone brought us — among many others — <a href="https://www.zdnet.com/article/codecov-breach-impacted-hundreds-of-customer-networks/">codecov</a>, the <a href="https://fossa.com/blog/embedded-malware-npm-coa-rc-ua-parser/">npm coa/rc/ua-parser hijacking</a>, and the recent and <a href="https://logging.apache.org/log4j/2.x/security.html">highly disruptive log4j vulnerability</a>.</p><p>Once an attacker gains a foothold within an organization’s CI/CD ecosystem, they will look to advance their position within, en route to eventually finding and exfiltrating valuable assets. To move within the ecosystem (e.g., SCM to CI, or CI to an artifact repository, etc.), the attacker will strive to perceive a graph representation of the ecosystem, looking for the relationships between the different systems.</p><p>From the attacker’s perspective, the ecosystem is not a group of isolated &amp; siloed systems but a graph of highly interconnected systems, which contrasts the traditional <a href="https://github.com/JohnLaTwC/Shared/blob/master/Defenders%20think%20in%20lists.%20Attackers%20think%20in%20graphs.%20As%20long%20as%20this%20is%20true%2C%20attackers%20win.md">defender list mindset</a>, where systems and assets are secured individually in a silo.</p><p>It’s my experience that both dev and security share similar concerns about the role that CI/CD plays in the organization’s attack surface. I vividly remember a moment in one of my previous companies where I became concerned with the inadequate visibility we had into our CI/CD ecosystem. Ultimately, we had to deploy pipelines that had access to, and credentials of, the most sensitive environments storing our customers’ most lucrative data.</p><p>Even though this was the reality, I did not feel we understood the blast radius of a security breach in some of the systems, and whether or not, ultimately, the assets that our customers were entrusting us with — were safe.</p><p>At Cider, we understood that to effectively and holistically secure CI/CD ecosystems, we must match the attacker’s perspective and think in graphs rather than lists.</p><p>Making this decision is the trivial part — modeling &amp; engineering is where the challenge comes in;</p><h3>CI/CD graph modeling &amp; engineering</h3><p>CI/CD ecosystems are complex, typically consisting of multiple systems, where each system is often complex by its own merit. In addition, each type of system is usually offered by several different vendors (with both overlapping and distinct features and properties), and each system can often integrate with several other systems by more than one means.</p><p>Here’s a simplified overview of a modern CI/CD ecosystem for demonstration:</p><ul><li>Source control management: A Github organization will consist of numerous users, collaborating on multiple repositories, sending webhook events on a variety of triggers, with endless branches and commits correlating to various branch protecting rules and conditions — and that’s just the tip of the iceberg.</li><li>Dependency/artifact management: Organizations typically use multiple package registries simultaneously (e.g., npm/JFrog), potentially containing millions of packages each, where each package is nesting its own dependency tree.</li><li>Integration: Jenkins pipelines can be executed by both pull and push; be defined inline or by manifests located in arbitrary repositories and branches. Jenkins’ marketplace consists of more than a thousand plugins that can extend or alter pipeline behavior.</li><li>Deployment: the OCI distribution specification helps standardize the distribution of container images; however, there are multiple overlay vendors with different authentication schemes (e.g., ECR, GCR, DockerHub, etc.).</li><li>Production: K8s consists of around ten baseline objects of varying complexity, but is also highly extendable. Understanding the structure of the underlying infrastructure (whether it’s cloud or on-premise) is important for a comprehensive view of the production environment.</li></ul><p>The above is a partial and low-resolution overview of a basic CI/CD ecosystem, but it does demonstrate the key resource families that can be modeled in a CI/CD graph, and I’ll refer to them throughout.</p><p>Here’s a more in-depth view of some of the interesting considerations and challenges we encountered at Cider while modeling and implementing CI/CD graphs:</p><p><strong>1. Naive vs. intelligent relationships</strong></p><p>Some intra-system relationships become apparent by simple observation. For example, an SCM repository that contains an SCM branch is easily observable, and a simple GraphQL response transformation can generate the appropriate nodes and edges.</p><p>In contrast, determining the effective permissions of an SCM user against an SCM branch is a more involved effort. It requires processing the user’s permissions against the relevant SCM organization &amp; against the relevant SCM repository, as well as the branch protection rules of the SCM repository.</p><p>Inter-system relationships are also often complex. For example, can you try to accurately, in high resolution, model whether a developer (or, more likely, a DevOps engineer) in your organization can push code directly to production? What about indirectly?</p><p><strong>2. Variance in graph resolution</strong></p><p>There’s good correlation between the resolution of the data in the graph and the insight an organization can derive from it. The aforementioned basic overview is a low-resolution one — although it covers a lot of ground, it contains little insight.</p><p>In contrast, consider a potential subgraph of a container registry. The most basic and low-resolution subgraph consists of a single node that represents the registry as a whole. However, increasing the resolution, nodes representing the registry’s repositories emerge, followed by the images of each repository… the layers of each image in each repository… the content of each layer… and so on, and so forth.</p><p>With these high-resolution nodes in mind, not only are we already able to gain interesting insight into the container registry (e.g., images’ SBOM), but we have also discovered opportunities to create intelligent relationships between the higher resolution nodes to nodes of different systems (for example a package in a container image that is identical to a package in JFrog repository — or even more interestingly, a package in a container image that has an identical name but different content in comparison to its JFrog counterpart).</p><p><strong>3. Variance in raw data (frequency, volume, interfacing)</strong></p><p>Raw data that can be transformed to graph nodes and edges comes in all shapes, sizes, and frequencies.</p><p>Roughly speaking, the higher resolution data will be naturally more granular and change more frequently. Following up on the container registry example, the lower resolution nodes (the actual registry and the contained repositories) will change infrequently, whereas the higher resolution nodes (the images and the underlying layers) will change frequently — and the changes will often carry greater deltas (e.g., imagine the changes to a package-lock.json when new packages are introduced).</p><p>Additionally, the higher resolution data will often require more advanced extraction and processing methods, while the lower resolution data is often retrievable by simple REST or GraphQL requests.</p><p>Following up on the container registry example: listing the images of some container registry repository is easily achievable via a REST request — however, deriving the full SBOM graph (with both OS-level packages and application-level packages) of a new image in the aforementioned repository is a significantly more involved process.</p><p><strong>4. Data integrity, versioning, and resiliency</strong></p><p>Besides the interesting challenge of modeling CI/CD graphs, retrieving the required data, transforming it, and storing it in a way that’s performant, resilient, and consistent is likewise an interesting challenge.</p><p>As previously mentioned, the relevant raw data comes in in all shapes, sizes, and frequencies. Some data is more appropriate to be pulled periodically, whereas other data is more efficiently retrieved via registration to push events or streams.</p><p>The synchronization of all the different data avenues is critical to ensure consumers of the graph are consuming consistent data that is not in a transient state.</p><p>It is not enough to rely on ACID stores, as the interoperability between the CI/CD systems is great, where a single change in a high-resolution node may lead to a cascade of altered intelligent edges and nodes.</p><p>The process of determining the new relationships in such an event often involves a sequence of operations that have to be performed asynchronously due to both a potentially high number of hops, as well as prolonged execution durations.</p><p>In the interim, the graph must remain in a consistent state — albeit not necessarily accurate in terms of real-time representation. How accurate your graph must be in terms of real-time representation is derived from your SLA considerations, which may indeed lead to very different architectures.</p><p><strong>5. Graph presentation and interaction: user-friendly nodes/edges vs. algorithmic nodes/edges</strong></p><p>Another interesting topic in the realm of CI/CD graphs is user-friendly nodes and edges. Although high-resolution nodes and edges are great for deriving in-depth insights, they’re not all necessarily adequate for the presentation layer, often being noisy or just not interesting for observation in many cases.</p><p>In particular, intelligent edges between high-resolution nodes meant for vector calculations are often not intuitive or user-friendly. Therefore, derivative user-friendly nodes and edges should sometimes be generated to present the insights in a user-friendly and intuitive way.</p><p>Furthermore, user interaction is another interesting challenge. Users may want to, for example, simulate how an altered configuration of a resource affects blast radius. A translation layer between the user-friendly nodes/edges and the algorithmic nodes/edges can be implemented to achieve the required bi-directionality.</p><p><strong>6. Data normalization</strong></p><p>Each type of CI/CD system is often offered by several different vendors. Between the various vendors, there are varying degrees of overlap in terms of features and properties. When building generic CI/CD graphs, our motivation is to be able to present a vendor-agnostic representation of the ecosystem; otherwise, each integration of a system into our graph will be tedious.</p><p>Under ideal circumstances where the overlap is great (e.g., container registries), adding integration with a new vendor will merely require a thin transformation layer, and all relevant deliverables will work without much additional effort.</p><p>Typically, systems based on standardized protocols or specifications (e.g., Git, OCI, etc.) will contain substantial overlap between the different vendors and will be easier to normalize, whereas the non-standardized ones will be more difficult.</p><p>As such, it’s important to strive for normalized nodes and edges — but to also know when to “throw in the towel” and define vendor-specific ones. Some properties and relationships are entirely vendor-specific, where attempts for generic expression are futile.</p><h3>Derived insight from CI/CD graphs</h3><p>So we’ve modeled and engineered a graph. We took care of every one of the considerations mentioned above — but that is just the first half of our journey. Now it’s time to capitalize on the data;</p><p>Here are some prominent examples:</p><p><strong>1. Enhanced observability at scale</strong></p><p>The lower to medium resolution nodes and edges represent the major resources in a CI/CD ecosystem, such as SCM repositories, SCM users, CI pipelines, container registry repositories, etc. Each one of these nodes is potentially connected to several of the other nodes-making a tabular representation of the ecosystem somewhere between highly confusing and not possible.</p><p>For example, imagine the average medium-sized organization, maintaining a few hundred SCM repositories. Each repository is potentially accessible by various means; username/password, SSH key, access token, OAuth token, and more. Repositories trigger builds off of various conditions — considering the source branch, branch protection rules, and other factors.</p><p>Ultimately, understanding which humans — and which applications — have the permissions to trigger which CI pipeline — and under what conditions — relies upon complex queries and conditions that cannot be adequately calculated by means that are based on tabular data representation.</p><p><strong>2. Basic attack vector/blast radius discovery</strong></p><p>Basic attack vectors become observable in higher resolution data, and the likelihood of correct identification of a vector increases with resolution and volume. The more auxiliary components and guardrails represented in the graph, the more false vectors can be eliminated, and the more refined blast radiuses can be derived.</p><p>For example, imagine a subgraph of a K8s cluster. Some possible nodes in such a subgraph are pods, containers, image layers, layer SBOM, etc. Additionally, let’s suppose we identified a vulnerable version of log4j in one of the layers’ SBOM.</p><p>On the one hand, with enough volume and a high enough resolution, this can allow an attack scenario that leads all the way to the underlying cloud infrastructure (e.g., via lateral movement to a privileged pod) or to a database with customer data (e.g., reading a mounted secret).</p><p>Alternatively, the same scenario can lead to absolutely nowhere, e.g., the library isn’t loaded to the memory, or no significant lateral movement is possible.</p><p>The latter is nonetheless a security risk — however, the difference in severity from the former is significant, and it is essential to be able to make the distinction.</p><p><strong>3. Advanced attack vector/blast radius discovery</strong></p><p>The log4j scenario described above is potentially disastrous — however, its graph discovery and representation are reasonably straightforward.</p><p>At Cider, we’re engaged in researching advanced CI/CD vectors, often involving tens of high-resolution nodes with multiple different inter-system edges between the various nodes.</p><p>A nice example of what we consider an advanced vector is a vector, or rather a combination of several different vectors, that accurately describe whether a CI/CD pipeline will be executed on a pull request or a pushed commit to an SCM repository — and if so, what code will be executed in the pipeline, and what sensitive information is potentially accessible to that code.</p><p>Sensitive information may indeed be exfiltrated (e.g., codecov), but it doesn’t necessarily end there. CD pipelines often have access to credentials that, unsurprisingly, facilitate continuous delivery. These pipelines will often contain access to write credentials to your container registry, your K8s API, and other production-related integrations.</p><p><strong>4. Attack vector/blast radius simulations</strong></p><p>I’ve briefly touched on simulations before, and indeed, simulating different high-resolution CI/CD graph states based on simulated modifications to a live CI/CD system is a powerful discoverability measure.</p><p>The relationship between security, DevOps, and dev teams involves a continuous cycle of give and take — applying the most comprehensive and strict security measures for every feature or component in every system might severely hinder development velocity, and consequently, hinder GTM or TTM.</p><p>On the other hand, disregarding security will eventually lead to the accumulation of significant security debt, which will become progressively more challenging to account for.</p><p>It is therefore imperative to find the right balance — however that is often easier said than done. As evident, CI/CD ecosystems are complex, and understanding the full effect on the blast radius of lacking a security measure or control is difficult without at least a moderately high-resolution CI/CD graph.</p><p>By employing a high-resolution CI/CD graph, different states based on different simulated security controls can be derived algorithmically and visualized in a user-friendly presentation.</p><p><strong>5. Discoverability</strong></p><p>The dynamic and fast-paced nature of today’s engineering ecosystem has caused managing our environments with configuration/infrastructure-as-code, rather than manually, inevitable — it is imperative to achieve maximal replicability and restorability.</p><p>However, for various reasons, exceptions are often made — resources are not deployed via IaC; permissions are granted ad-hoc; code is not templated, etc.</p><p>Machine learning for graphs can help discover patterns and anomalies in CI/CD ecosystems. Applying unsupervised clustering algorithms on graphs can uncover both lower-resolution anomalies (e.g., unusual SCM user permissions, unusual SCM repository branch protection rules, etc.), as well as higher-resolution anomalies (e.g., unusual Dockerfile base images, unusual K8s manifests, unusual SBOM, etc.).</p><h3>Closing thoughts</h3><p>Graph structures and algorithms have excellent synergy with CI/CD ecosystems. Dramatically improved low-resolution visibility and high-resolution blast radius discovery are just some of the possible benefits of representing CI/CD ecosystems with graphs.</p><p>However, successfully doing so at scale is a challenging yet fascinating R&amp;D endeavor. CI/CD systems have hundreds of potential graph nodes and edges to be modeled, requiring the orchestration of multiple, diverse, and often complex data sources.</p><p>Fortunately, the task is as fascinating as it is challenging. There’s virtually no limit to how complex &amp; high-resolution your graph may be.</p><p>From exploring and modeling esoteric or extremely high-resolution data through making sure your infrastructure &amp; application tiers support its retrieval and presentation in a way that’s scalable and efficient, CI/CD graphs are an R&amp;D oasis.</p><p>These capture the essence of the challenges, dilemmas, and thoughts processes that make up for our day-to-day at Cider when working on CI/CD graphs. If you find this topic as fascinating as I do, I am always looking to exchange thoughts and ideas. Feel free to reach out to me at my <a href="/service/mailto:leon@cidersecurity.io">email</a> or DM me on <a href="https://www.linkedin.com/in/leon-goldberg/">LinkedIn</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22dfa38c9d09" width="1" height="1" alt=""><hr><p><a href="https://medium.com/cider-sec/visualizing-ci-cd-from-an-attackers-perspective-22dfa38c9d09">Visualizing CI/CD from an attacker’s perspective</a> was originally published in <a href="https://medium.com/cider-sec">Cider Security</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>