<?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 Torsten Boettjer on Medium]]></title>
        <description><![CDATA[Stories by Torsten Boettjer on Medium]]></description>
        <link>https://medium.com/@torsten.boettjer?source=rss-5652805b5afd------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*2UnBIVAQ3j72OCCv.</url>
            <title>Stories by Torsten Boettjer on Medium</title>
            <link>https://medium.com/@torsten.boettjer?source=rss-5652805b5afd------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 22:24:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@torsten.boettjer/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[Internal Agent Platforms, the next Evolution of Platform Engineering]]></title>
            <link>https://medium.com/@torsten.boettjer/internal-agent-platforms-the-next-evolution-of-platform-engineering-0fd5775964c0?source=rss-5652805b5afd------2</link>
            <guid isPermaLink="false">https://medium.com/p/0fd5775964c0</guid>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[enterprise-technology]]></category>
            <category><![CDATA[digital-sovereignty]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agents]]></category>
            <dc:creator><![CDATA[Torsten Boettjer]]></dc:creator>
            <pubDate>Sun, 22 Nov 2026 14:17:53 GMT</pubDate>
            <atom:updated>2026-11-22T14:43:52.980Z</atom:updated>
            <content:encoded><![CDATA[<p><em>From deploying applications to delivering governed AI agents on infrastructure you control.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dpRJrxfeDNDYZgvMY7672A.png" /></figure><p>For years, Internal Developer Portals (IDPs) have helped organizations turn infrastructure complexity into a self-service experience for software teams. Developers get standardized environments, deployment pipelines, service catalogs, and operational guardrails. Platform teams maintain the foundation, while application teams focus on business value.</p><p>AI agents are creating a similar challenge and an opportunity to extend that model.</p><p>Today, an organization might have one team building a support assistant, another experimenting with an operations copilot, and a third connecting a language model to internal APIs. Each project chooses its own model, framework, prompts, connectors, and security approach. The demonstrations may be impressive. Operating them reliably across the business is harder.</p><p>What if we treated agents as an internal platform capability, rather than a collection of AI experiments?</p><p>That is the idea behind the Internal Agent Platform (IAP).</p><h3>From the IDP to the IAP</h3><p>An Internal Developer Portals (IDP) makes it easier to build, deploy, and run conventional software. An Internal Agent Platforms (IAP) extends the same principles to agents: reusable building blocks, standardized delivery, governed access to business systems, and observable operation.</p><p>The analogy is useful:</p><ul><li>Application templates become agent templates and reusable skills.</li><li>Service catalogs expand into catalogs of agents and governed capabilities.</li><li>Deployment pipelines are joined by agent evaluation and release processes.</li><li>Application observability expands to include tool execution, decision evidence, and agent quality.</li><li>Developer portals are complemented by custom agent interfaces for business users.</li></ul><p>The agent platform doesn’t replace the developer portal. Where the portal gives people self-service access to systems, the platform lets agents use those same systems to complete tasks on their behalf. Agents work through the APIs, databases, applications, and infrastructure already in place, and the platform adds the capabilities needed to deliver intelligent, task-oriented services.</p><h3>A business user needs an application, not a prompt window</h3><p>Consider an operations manager investigating a delayed order, a failed settlement, an insurance claim exception, or a service incident.</p><p>The manager does not want to select a model, configure tools, or learn an agent framework. They want to open a purpose-built workspace, inspect the case, understand what is blocking it, and decide what to do next.</p><p>A custom agent interface might combine a conversational question with a case timeline, supporting evidence, recommended next steps, and approval controls.</p><p>Behind that interface, a governed agent runtime coordinates tasks and model calls. The model interprets questions and drafts explanations. But the business meaning of a case, the authoritative data sources, and the permitted actions must come from somewhere more reliable than the model’s guesses.</p><h3>Why enterprise context is the missing layer</h3><p>Imagine asking an agent: <em>“Why is case XYZ-1042 unresolved, and what should we do?”</em></p><p>To answer, the agent may need to connect a customer order to a shipment, a supplier acknowledgment, a service-level agreement, and a workflow owner. These relationships are not merely pieces of text that happen to be semantically similar. They are business facts and dependencies.</p><p>Rescile approaches this problem through an ontology-driven graph that represents a structured model of entities, relationships, data sources, and rules. Its MCP interface and generated agent guidance helps compatible agents discover modeled context and defined capabilities.</p><figure><img alt="The three tier platform architecture" src="https://cdn-images-1.medium.com/max/1024/1*W7ezW-a0YnGpRIFHfP-GGg.png" /><figcaption>Platform Architecture</figcaption></figure><p>The broader solution architecture uses controlled execution components to retrieve information from authoritative systems, apply deterministic calculations, and return bounded results. These capabilities are verified for the chosen deployment rather than assumed to be universally available out of the box.</p><p>The principle is straightforward, let the AI interpret the request, but let explicit business models and governed systems determine what the answer means and which actions are allowed.</p><h3>The four parts of an Internal Agent Platform</h3><p>The agent platform architecture separates responsibilities:</p><ol><li><strong>AI Models:</strong> Open-weight models that can run on-prem or at a trusted provider, and where policy allows, closed frontier models, used for interpretation, reasoning, and drafting. Model choice remains flexible and can differ per use case.</li><li><strong>Governed Agent Runtime:</strong> A sandboxed execution environment that runs an open-source AI agent harness without local file system access, supporting data loss prevention (DLP). It governs skills, tool use, orchestration, and workflow boundaries.</li><li><strong>Rescile Context &amp; Control Engine:</strong> The ontology, dependencies, policies, MCP capabilities, and governed action definitions that connect the agent to enterprise reality. It acts as the guardrail layer, enforcing financial, compliance, and security rules on every request and on every result returned to the agent.</li><li><strong>Existing Systems of Record:</strong> The ERP, CRM, core systems, workflow tools, data platforms, and monitoring that remain authoritative for operational facts and transactions.</li></ol><p>Business users interact with the platform through questions, decisions, and approvals. Every request an agent makes passes through the Context &amp; Control Engine, which grants only authorized access to the systems of record and filters what comes back. This separation allows a bank, manufacturer, or logistics provider to build very different agent experiences while reusing the same platform principles.</p><h3>Internal means controlled, not disconnected</h3><p>“Internal” describes who controls the platform, not where it runs. The Governed Agent Runtime and the Context &amp; Control Engine can be deployed on-premises, in a private cloud, or at a trusted provider, whichever fits the organization’s requirements, and they sit next to the systems of record they connect to. Wherever they run, the organization keeps control over deployment, networking, secrets, upgrades, and operational evidence, and agent activity stays inside boundaries it already governs.</p><p>The AI models are the exception. Open-weight models can run on-prem, but if an agent calls an externally hosted model, information may cross the organization’s boundary. On-premises deployment improves sovereignty, yet the model call is where that control has to be managed actively. Model licensing, inference-provider contracts, data retention, and residency become new disciplines for platform architects and engineers.</p><p>This is where the layers work together. The Context &amp; Control Engine decides which data and actions an agent may use and filters what comes back, so policy, not convenience, determines what reaches a model. The important design choice is to keep the architecture flexible enough to use hosted inference where policy allows and local inference where it is required.</p><h3>Governance should shape what an agent can do</h3><p>An agent that summarizes a case is different from an agent that changes a customer record, releases a payment, or modifies production infrastructure.</p><p>A sensible adoption path starts with read-only investigation. The agent then prepares recommendations and drafts actions for review. Only after validation should it execute narrowly defined changes, subject to identity, permissions, approvals, audit evidence, and operational safeguards.</p><p>The objective is not unrestricted autonomy. It is reliable assistance with clear accountability.</p><h3>Start with one measurable workflow</h3><p>A successful platform initiative does not need to begin with a company-wide roll-out.</p><p>Choose a high-friction process, perhaps exception investigation, campaign analysis, claims triage, or infrastructure incident assessment. Model the relevant entities and dependencies. Connect a small number of authoritative sources. Deliver a focused agent interface. Then measure accuracy, time to resolution, human review effort, and cost per accepted task.</p><p>If the pilot works, reuse its platform components for the next agent. That is how isolated projects become an internal capability.</p><h3>From infrastructure to intelligence</h3><p>The most interesting shift is not that agents can call tools. It is that organizations can begin delivering them with the same discipline they apply to applications: standardized building blocks, explicit ownership, controlled access, repeatable releases, and operational evidence.</p><p>The Internal Agent Platform is a proposed next step in that evolution, not a replacement for the developer portal, but an extension of platform engineering into intelligent applications.</p><p>At Rescile, we see the ontology-driven context and control layer as a foundation for this direction: connecting flexible models and an agent runtime to the business systems, relationships, and rules that make agents useful in real operations.</p><p>Your infrastructure. Your models. Your agents. Your rules.</p><p><em>Explore Rescile at </em><a href="https://www.rescile.com/"><em>rescile.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0fd5775964c0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When a CVSS 10.0 Headline Hits: Why "What’s Actually Running" Beats "What’s Documented"]]></title>
            <link>https://medium.com/@torsten.boettjer/when-a-cvss-10-0-headline-hits-why-whats-actually-running-beats-what-s-documented-be12a94da318?source=rss-5652805b5afd------2</link>
            <guid isPermaLink="false">https://medium.com/p/be12a94da318</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[vulnerability-management]]></category>
            <dc:creator><![CDATA[Torsten Boettjer]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 15:50:24 GMT</pubDate>
            <atom:updated>2026-09-02T19:02:27.267Z</atom:updated>
            <content:encoded><![CDATA[<p>A few weeks ago, a former colleague of mine reached out after a critical vulnerability disclosure , the kind with a CVSS score of 10.0, active exploitation in the wild, and known-affected companies already showing up in the news. His first reaction was the one every IT and security lead knows well. A brief moment of dread, immediately followed by the only question that matters: “ am I affected, and what depends on it?”<br>We had talked back in August about a problem that’s only getting harder as technical and regulatory complexity grows. How do you actually stay in control of your IT estate? Not the planned estate, the one in your CMDB, your architecture diagrams, your last audit, but the one that is actually running, with every dependency, every change, every drift from the plan baked in.<br>He’d tried Rescile UCS on his own projects after seeing what we have been building it for. Even though it is early stage, this is the kind of problems we intend to address with the solution. When the vulnerability news broke, he told me something that stuck with me: the CVE itself stopped being the interesting question. What mattered was tracing it, where it touched him, what depended on it, and what his real options and trade-offs were. That’s the exact question a static asset inventory can’t answer on its own, and it’s the one Rescile UCS is built to answer directly.</p><h3>The problem with &quot;documented&quot; infrastructure</h3><p>Most organizations already have an asset inventory, a CMDB, or a SBOM archive somewhere. The trouble is that all of these are snapshots , accurate on the day someone updated them, and slowly diverging from reality every day after. When a critical CVE lands, the real question isn’t &quot;do we have this library documented somewhere,&quot; it’s &quot;where is it actually deployed, in which image, in which application, and who owns the decision to remediate it.&quot; Answering that from a spreadsheet or a quarterly asset scan means either a multi-day fire drill or, worse, a confident wrong answer.</p><h3>What changes when the CMDB lives in the pipeline</h3><p>Rescile UCS takes a different starting point. Instead of asking teams to describe their environment after the fact, it observes what’s actually deployed by sitting directly in the CI/CD flow. Every container image that ships carries its SBOM with it, and UCS keeps that as the living inventory, not a document, but a graph that connects four things that are usually scattered across different tools and teams:</p><ul><li>Software components, the actual packages and versions in your SBOMs, deduplicated across every image they appear in.</li><li>Vulnerabilities, CVEs linked directly to the components they affect, not to the application as a vague label.</li><li>Applications and deployments , which container image, which digest, which repo a component actually shipped in.</li><li>Ownership, who is Accountable, Responsible, and Consulted for each application, down to the operational provider and the legal entity behind it.</li></ul><p>The result is that a single finding can be traced end-to-end. What used to be a cross-team investigation becomes a lookup.</p><p>If you’re maintaining your own asset inventory by hand, or trusting a periodic scan to tell you what’s really running, it might be worth asking the same question my colleague did, not &quot;is this CVE bad&quot; but &quot;where does it actually touch me, and who needs to know.&quot; That’s the question Rescile UCS is built to answer.<br>I’d be curious how others are approaching this, are you relying on a traditional CMDB, a scanner, or something that lives in your pipeline the way this does? Let me know in the comments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IElAHOly09NEDmwq-N52FA.jpeg" /><figcaption>Impact trace from a critical CVE through the affected component, image, application, and accountable owner</figcaption></figure><h3>From &quot;which CVEs exist&quot; to &quot;who needs to act, today&quot;</h3><p>The vulnerability register itself isn’t new, most scanners can tell you a CVE exists in a package. What’s different is that because the data comes from the pipeline rather than a periodic scan, it reflects what’s genuinely deployed today, including how many applications and images share the same affected component, and how many distinct paths through the graph lead back to it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DPHbcXcb7rhj1Zt9utg86w.jpeg" /><figcaption>Vulnerability register showing severity, affected package, and how many applications each finding touches</figcaption></figure><p>Combine that with RACI-based ownership, captured not as a policy document but as structured, queryable assignments per application and every finding resolves to a named accountable party and provider, with full coverage tracked, in this example, 100% of required assignments across five applications.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Eb_T14UWl7Wx0q8tPfyRJg.jpeg" /><figcaption>Ownership &amp; RACI register with provider and legal-party boundaries per application</figcaption></figure><h3>Why this matters beyond the fire drill</h3><p>The immediate use case, &quot;am I affected by this CVE&quot;, is what gets people’s attention, but the underlying shift is broader. Once you have an accurate, continuously updated picture of what’s actually deployed, dependencies and all, things like compliance evidence, governance reporting, and change-impact analysis stop being separate, manual exercises. They become queries against the same graph. That’s especially relevant for organizations operating under frameworks like FINMA, DORA, or NIS2, where the expectation is increasingly that you can demonstrate what’s running and who’s accountable for it, not just that a policy exists.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hx8sJsBZbrJTtoLFquQYZA.jpeg" /><figcaption>Application register connecting repos, deployed images, SBOM coverage, and named owners</figcaption></figure><h3>Try it yourself — it’s free</h3><p>If you’re maintaining your own asset inventory by hand, or trusting a periodic scan to tell you what’s really running, it might be worth asking the same question my colleague did, not &quot;is this CVE bad&quot; but &quot;where does it actually touch me, and who needs to know.&quot; That’s the question Rescile UCS is built to answer.<br>I’d be curious how others are approaching this, are you relying on a traditional CMDB, a scanner, or something that lives in your pipeline the way this does? Let me know in the comments.</p><p><em>About the authors</em></p><p><em>Jens Binkert and Torsten Boettjer launched Rescile after working in Platform Engineering for more than two decades. Their mission is transforming secure cloud configuration into a community-driven effort that replaces manual scripting with autonomous agents. The Unfied Configuration Server ensures that application requirements are translated into compliant, self-reconciling infrastructure without the overhead of traditional configuration management.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be12a94da318" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Operational Sovereignty: “Who Controls Your Infrastructure?” Is the Real Question]]></title>
            <link>https://medium.com/@torsten.boettjer/operational-sovereignty-who-controls-your-infrastructure-is-the-real-question-26cc8c5bbc79?source=rss-5652805b5afd------2</link>
            <guid isPermaLink="false">https://medium.com/p/26cc8c5bbc79</guid>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[digitale-souveränität]]></category>
            <dc:creator><![CDATA[Torsten Boettjer]]></dc:creator>
            <pubDate>Sat, 04 Jul 2026 04:53:05 GMT</pubDate>
            <atom:updated>2026-07-04T11:13:33.864Z</atom:updated>
            <content:encoded><![CDATA[<p>For the last decade, European enterprises answered the sovereignty question mainly from a geographical perspective. Point to a cloud region inside the EU, tick the box and carry on. But actually, this was never really about sovereignty, it was about data residency. The harder question has always been sitting underneath it: whose management plane, whose automation logic, whose proprietary console do you actually depend on to run your infrastructure day to day?</p><p>DORA, NIS2, BAFIN and FINMA (in Switzerland) all share a quiet but radical premise: a regulated institution has to control the systems that govern its infrastructure, not merely rent capacity from a provider it trusts. That distinction, between using a vendor’s infrastructure and depending on a vendor’s control plane to operate it, is what “operational sovereignty” actually means. And it’s the gap that most cloud-era tooling was never built to close.</p><h3>The dependency, platform engineers seldom take into account</h3><p>Public cloud gave infrastructure teams speed. It also quietly made them dependent, not on any single data center, but on a vendor’s proprietary management plane to operate their own systems, on a SaaS console that holds their architectural knowledge hostage to a subscription, on an external service to run compliance checks that regulators expect them to own. Switch providers, and you don’t just migrate workloads, you rebuild your entire operating model from scratch.</p><p>Under DORA and NIS2, that dependency isn’t just an inconvenience to route around with a good exit clause. It’s a governance liability. A financial institution can’t outsource accountability for its own operational resilience to a vendor’s roadmap. A critical infrastructure operator has to be able to demonstrate, to an auditor, on demand, that it controls its own processes, not that it trusts a provider not to change the terms.</p><p>Most tooling built for this problem approaches it backwards: bolt compliance reporting onto infrastructure that was never modeled with governance in mind, and hope the spreadsheet holds together until the next audit. It rarely does.</p><h3>A different starting point: a resource graph</h3><p>This is the problem Rescile set out to solve with rescile UCS, a self-hosted automation server the team describes as a “requirements engine for agentic infrastructure.” The core idea is simple to state and hard to retrofit: instead of managing infrastructure through disconnected scripts, tickets, and tribal knowledge, rescile models your entire hybrid estate, on-premise hardware, virtualized environments, and public cloud services, as a single, queryable resource graph.</p><figure><img alt="Analyzing complex infrastructure dependencies." src="https://cdn-images-1.medium.com/max/1024/0*DTR9EKXbkDW1GVxp.png" /><figcaption>Visualizing the dependencies in a ResourceGraph</figcaption></figure><p>Once your applications, databases, networks, and compliance controls exist as nodes and edges in that graph, questions that used to trigger a cross-departmental fire drill become a query:</p><ul><li>What’s the blast radius if this database fails?</li><li>Which applications are still missing DR replicas?</li><li>What breaks if we decommission this network segment?</li></ul><p>That queryability is the foundation everything else is built on, including sovereignty itself.</p><h3><strong>Built by the people who know your system, not by an automated guess</strong></h3><p>The graph bridges an important gap between DevOps and ITSM, providing a dynamic source of truth. In modern IT, the &quot;Infrastructure as Code&quot; repository became for DevOps what the CMDB is for ITSM, a static system of record. Both suffer from the same flaw. A central engineering team gates all write access. Everyone else files requests and waits. While this strict gatekeeping ensures data completeness, it creates a massive bottleneck that simply cannot keep up with the rapid pace of cloud and AI platforms. It turns model accuracy into a privileged-access problem, where every single update requires someone with elevated rights to execute it.<br>To bypass this bottleneck, am increasing number of management tools take a dangerous shortcut: they deploy discovery engines to automatically infer dependencies. While fast, this approach is fundamentally shallow. An algorithm can see that a VM exists within a specific subnet, but it cannot see why a DBA provisioned a replica a certain way, what network segmentation security requires, or what historical context the compute team holds from past incidents. That critical institutional knowledge lives in people, not API responses. A purely scraped database will always be blind to it.<br>Rescile’s solution? We transform your infrastructure graph into a genuinely collaborative artifact, moving away from both algorithmic guessing and gatekept databases.<br>Because our model is defined declaratively using version-controlled TOML, rather than rows in a proprietary database, your specialists maintain true ownership:</p><ul><li>DBAs own and submit definitions for database resources</li><li>Network Admins define segmentation and routing</li><li>Compute Admins manage virtualization and bare metal</li></ul><p>Everyone contributes through the same Git-based workflow they already use daily. Ownership of the graph maps naturally to pull requests, reviewed and merged like standard code. No one needs privileged access to a shared system just to keep their data accurate, and no single team becomes a bottleneck.<br>The result is an infrastructure graph you can actually trust. Built from the ground truth of your specialists, updated at the speed of their own workflows, and fully auditable through standard Git history.</p><h3>Compliance-as-code instead of compliance-by-spreadsheet</h3><p>But we don’t stop at sys admins to become part of the governance process. rescile lets security teams define security and compliance policies, encryption requirements, data residency rules, network segmentation, disaster-recovery posture, as declarative rules in code. Topology definitions and deployment rules are evaluated against the live graph that now includes security and compliance controls, not reconstructed manually every audit cycle. Gaps surface immediately as a query result instead of during a panicked evidence hunt the week before an auditor arrives.</p><p>For institutions that need to produce formal evidence, rescile generates OSCAL-formatted System Security Plans directly from the graph. The output isn’t a claim about compliance, it’s a structural artifact generated from the same model that’s actually driving your infrastructure.</p><h3>Sovereignty as architecture, not policy</h3><p>Here’s the part that matters most for regulated industries: rescile itself runs entirely inside your boundary. It’s a self-hosted, single-binary controller, deployable on-premise, in your own private cloud, or in a fully air-gapped network that never touches the public internet. There’s no telemetry, no phone-home licensing check, no external dependency required for the graph, compliance, or output engine to function.</p><p>That’s a meaningfully different guarantee than a vendor’s promise to let you export your data on request. It’s not a contract term that can quietly change with the next pricing update, it’s how the software is built. Your resource graph, your compliance rules, and your architectural logic never depend on a provider’s uptime, roadmap, or continued goodwill, because they never lived on a provider’s platform in the first place.</p><p>This is where operational sovereignty actually cashes out: avoiding provider dependency, not just avoiding a specific geography. Rescile stores your model in human-readable, version-controlled formats (TOML, JSON, CSV) that live in Git. There’s no proprietary format to reverse-engineer and no vendor console your team has to relearn its entire workflow around. If you ever want to switch providers underneath it, or walk away from rescile itself, your architectural intelligence goes with you in its entirety, because it was never locked inside anyone’s platform to begin with.</p><h3>From graph to action: automation without configuration drift</h3><p>A resource graph that only describes your estate is a nice diagram. Rescile treats it as a source of truth for automation. A single GraphQL query can generate a terraform.tfvars.json. A compliance rule can generate a firewall matrix automatically. Change the model, and every downstream artifact, Terraform variables, Ansible inventories, Kubernetes manifests, custom runbooks, ripples correctly, instead of drifting out of sync the way hand-maintained IaC inevitably does.</p><p>Teams can also package reusable architectural blueprints as versioned modules, and go further by shipping custom web interfaces, self-service portals, compliance dashboards, operations UIs, as Application Modules served directly by the controller and backed live by the graph. No separate frontend stack to build and maintain just to give other teams safe access to the model.</p><h3>Agentic operations, without giving up the boundary</h3><p>The most forward-looking piece is how rescile treats AI. Rather than exporting your architecture to an external AI platform to get useful answers out of it, rescile ships a built-in Model Context Protocol (MCP) server. AI agents get secure, structured access to the full resource graph, enough context to answer real architectural questions, assess compliance posture, and assist with remediation, while the underlying data never crosses your boundary.</p><p>This is, in a sense, the sharpest expression of operational sovereignty: agentic infrastructure operations that are genuinely useful, without making your AI strategy hostage to whichever platform happens to be hosting your architecture.</p><h3>Why this matters now for European enterprises</h3><p>Regulatory pressure in Europe is only tightening. DORA is now in force for financial entities. NIS2 is expanding the circle of organizations expected to demonstrate operational resilience, not just claim it. Boards and auditors are getting sharper questions to ask, and “our vendor is ISO certified” is increasingly not a sufficient answer when the real question is what happens to your operations the day that vendor changes terms, gets acquired, or simply stops being the right fit.</p><p>Operational sovereignty, understood this way, isn’t a compliance checkbox, it’s an architectural decision made early, about whether your control plane can be inspected, audited, and operated entirely by your own team, independent of any single provider. Tools like rescile make that decision easier by making independence a structural property of the platform, rather than a promise layered on top of someone else’s infrastructure that only holds until the contract changes.</p><p>For enterprises operating in regulated markets, that’s the difference between resilience you can claim and resilience you actually own.</p><h3>Join the Initiative and take control</h3><p>With rescile we launched initiative that is not about building a tool; our aim is, to build a Universal Library of Infrastructure Expertise. The complexity of the modern hybrid cloud shouldn’t be a proprietary black box or a manual chore.</p><p>As a Swiss initiative, we are committed to the values of neutrality, independence, and digital sovereignty. Our mission is to ensure that cloud customers, maintain absolute control over their architectural logic. By moving to a requirements-driven model, you aren’t just automating deployments; you are future-proofing your independence.</p><p>Get Involved, the Rescile engine is free and available at<a href="https://rescile.com/"> rescile.com</a>. Contribute to the Library by Sharing your models and help us build the world’s first open-source repository of agentic <a href="https://registry.rescile.com/">infrastructure blueprints</a>. The future of infrastructure isn’t a proprietary black box. It’s an open, intelligent, and requirement-driven ecosystem. Let’s build it together.</p><p><em>About the Authors</em></p><p><em>Jens Binkert and Torsten Boettjer launched Rescile after working in Platform Engineering for more than two decades. Their mission is transforming secure cloud configuration into a community-driven effort that replaces manual scripting with autonomous agents. The Unfied Configuration Server ensures that application requirements are translated into compliant, self-reconciling infrastructure without the overhead of traditional configuration management.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26cc8c5bbc79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Developing Infrastructure-as-Code (IaC), Your Cloud Needs a Requirements Engine]]></title>
            <link>https://medium.com/@torsten.boettjer/stop-developing-infrastructure-as-code-iac-your-cloud-needs-a-requirements-engine-f68d1c57505f?source=rss-5652805b5afd------2</link>
            <guid isPermaLink="false">https://medium.com/p/f68d1c57505f</guid>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[ai-in-devops]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Torsten Boettjer]]></dc:creator>
            <pubDate>Fri, 24 Apr 2026 13:30:17 GMT</pubDate>
            <atom:updated>2026-05-03T12:36:25.886Z</atom:updated>
            <content:encoded><![CDATA[<h4>DevOps is shifting from manual coding to intent-driven engines where agents translate high-level requirements into low-level infrastructure.</h4><p>For the past decade, IT managers have been trapped in a cycle of manual infrastructure coding. Configuration scripting became a high-stakes discipline with specialized cloud engineers managing a complex, brittle YAML and HCL codebase. Enterprise landing zones often evolved into monolithic “code-fortresses” that were more rigid than physical hardware and too complex to audit, ultimately defeating the very agility they were built to enable.</p><p>This technical debt trickles down to every department: Operation teams are forced to take over developer tasks. DevOps engineer wrestle with state files, keys and secrets - just to provision basic resources. Security and Compliance officers scan thousands of lines of code, hoping to find human errors and prevent a major breach.</p><p><strong>We have built a house of cards, and we’re calling it “DevOps.”</strong></p><p>It’s time to admit that the “Code” in IaC has become a tax on productivity rather than a facilitator. Moving forward, we don’t need another DSL; we need a radical simplification of the interface between business requirements and cloud reality.</p><h3>The Shift: From Scripts to Intent</h3><p>What if developers and application owners could define their needs in a simple table? What if security operators could enforce compliance with guardrails in a clean, human-readable format. What if cloud architects could use autonomous agents instead of manually tethering themselves to static templates in order to translate resource requests into cloud deployments?</p><p>This is the end of the “Configuration File” as we know it, and the birth of the <strong>Unified Configuration Server.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vw2iytmrme2yY3rEkocDLA.png" /><figcaption>Rescile’s extensible Configuration Server</figcaption></figure><h3>Intelligence Over Templates: The End of the Script Repository</h3><p>Traditional IaC tools are rigid script-runners. They execute exactly what you write, even if your code is a disaster or conflicts with a colleague’s work. Rescile’s Configuration Server works differently. It treats infrastructure as a Graph Retrieval and Synthesis problem, allowing experts to work autonomously without breaking each other’s code.</p><ol><li><strong>The Source:</strong> CSV files contain <em>intent</em>. Application Owners and Developers ask for a database or an app stack, providing a simple table; they don’t need to specify a VPC peering strategy or a security group rule.</li><li><strong>The Knowledge Base:</strong> The heart of the server is a collection of operational patterns captured in TOML. These models are maintained by experts (Security, Networking, FinOps) and are designed to remain extensible, allowing for individual requirements without necessitating a rewrite of the core logic.</li><li><strong>The Context:</strong> The engine acts as an intelligent synthesis layer. It builds on resource models and queries internal business systems or provider APIs to add operational context. It merges provider services with your intent into a GraphRAG system, supporting mutiple output interfaces.</li><li><strong>The Constraint Layer:</strong> Before a single resource get’s provisioned, the intent is filtered through TOML-based policy guardrails. If a request violates a security or FinOps policy, the engine auto-corrects it based on the Model’s logic.</li><li><strong>The Agent:</strong> Finally, the engine feeds this fully-contextualized “blueprint” to LLM-driven agents. Because agents understand the environment, the policy, and the intent, the agent generates a specific, environment-aware execution plan.</li></ol><h3>The Evolutionary Path: Obsoleting the Script</h3><p>If the thought of a total overhaul feels overwhelming, remember that you don’t have to dismantle your existing code all at once; our strategy focuses on incremental evolution, systematically evolving IaC modules into manageable, auditable models without disrupting your existing development process:</p><ul><li><strong>Step 1:</strong> Make script-rewriting obsolete by reusing your existing scripts for a dynamic configuration file export.</li><li><strong>Step 2:</strong> Move toward a dynamic interface, using the engine to injest resource dependencies accross modules.</li><li><strong>Step 3:</strong> Transition to full agentic autonomy, where the agent takes over the heavy lifting of extending the IaC process entirely.</li></ul><h3>The Three Wins</h3><ul><li><strong>For the Developer:</strong> You stop being an “Infrastructure Wrangler.” You define what you need in a row of a CSV and get back a resource URL.</li><li><strong>For the Platform Engineer:</strong> You stop being a “Ticket Factory.” You manage the <strong>knowledge base</strong> in TOML, allowing multiple experts to work autonomously without producing merge conflicts.</li><li><strong>For the CISO:</strong> You move from “Passive Auditor” to “Active Governor.” Security is an automated prerequisite, not a post-deployment checklist.</li></ul><blockquote>Built for Sovereignty: Rethinking global clouds with localized control.<br>Rescile is a Swiss based initiative. We build on the heritage of strict neutrality and technical exactness to protect your applications in the cloud. By separating “Intent” from “Provider,” our engine delivers true digital independence. This isn’t just about making deployments faster; it’s about governing your architectural logic with absolute precision. We ensure that your application remains yours, even in the cloud. We enable you to become flawlessly independent of any single vendor’s ecosystem</blockquote><h3>The Migration Path: From Legacy Scripts to Agentic Autonomy</h3><p>For two decades every approach to automate infrastructure deployment introduced a new “rip and replace” approach. Our engine is different. We designed the system to support incremental, risk-free transition, you decide how far you want to go when:</p><ul><li><strong>Level 1: Script Obsolescence </strong>— Dynamic configuration file exports replace manual coding, <em>sysadmins</em> review generated output.</li><li><strong>Level 2: Dynamic Interfacing</strong> — The Engine injects intent-based logic into your existing IaC codebase, <em>engineers</em> refine the TOML Models.</li><li><strong>Level 3: Agentic Platform</strong> — Autonomous agents manage the lifecycle from CSV to Cloud, <em>architects</em> define the Business Intent</li></ul><h3>The Future is Agentic, Requirement-Driven</h3><p>The era of “coding” your infrastructure is ending. We spent the last decade building increasingly complex languages just to describe how a server should be built. Today, we have the tools to describe what we need and let the system handle the how.</p><p>If you’re tired of fighting with Cloud-Init, YAML, or HCL, exhausted by ticket queues, or worried about the next compliance gap, it’s time to move up the stack.</p><p><strong>Stop managing scripts. Start managing intent.</strong></p><h3>Join the Initiative: Secure Cloud for Everyone</h3><p>But our initiative is not about building a tool; our aim is, to build a Universal Library of Infrastructure Expertise. The complexity of the modern hybrid cloud shouldn’t be a proprietary black box or a manual chore.</p><p>As a Swiss initiative, we are committed to the values of neutrality, independence, and digital sovereignty. Our mission is to ensure that cloud customers, maintain absolute control over their architectural logic. By moving to a requirements-driven model, you aren’t just automating deployments; you are future-proofing your independence.</p><p>Get Involved:</p><ul><li>Download the Engine: The Rescile engine is free and available at<a href="https://rescile.com/"> rescile.com</a>.</li><li>Contribute to the Library: Share your models and help us build the world’s first open-source repository of agentic <a href="https://registry.rescile.com/">infrastructure blueprints</a>.</li><li>Get in Touch: We are thrilled to present the framework at the upcoming Linux Foundation Open Source Summit in Minneapolis.</li></ul><p>The future of infrastructure isn’t a proprietary black box. It’s an open, intelligent, and requirement-driven ecosystem. Let’s build it together.</p><blockquote>Developer Note: Because our server exposes everything via JSON, REST, GraphQL and the Model Context Protocol (MCP), your infra-as-intent is already compatible with the tools you use every day. The future of infrastructure isn’t a terminal window; it’s a prompt.</blockquote><blockquote>About the Authors</blockquote><blockquote>Jens Binkert and Torsten Boettjer launched Rescile after working in Platform Engineering for more than two decades. Their mission is transforming secure cloud configuration into a community-driven effort that replaces manual scripting with autonomous agents. The Unfied Configuration Server ensures that application requirements are translated into compliant, self-reconciling infrastructure without the overhead of traditional configuration management.</blockquote><blockquote>Catch them speaking at the Linux Foundation Open Source Summit in Minneapolis this May.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f68d1c57505f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>