Welcome to rescile

From Complexity to Clarity — Build a Living Blueprint of Your Hybrid World.

In today’s IT landscape, critical information is scattered everywhere—across cloud consoles, CMDBs, spreadsheets, and tribal knowledge. Answering seemingly simple questions like “What’s the full cost of this application?” or “What’s the blast radius if this database fails?” or “Where to get the parameters and dependencies for deployment from?” can become a frantic, cross-departmental fire drill.

rescile solves this by transforming scattered data into a single, unified, and queryable dependency graph. This creates a living blueprint of the entire hybrid estate, from on-premise hardware to cloud services and the code that runs on them. By adopting a “configuration-as-code” philosophy—rule files in TOML or Jsonnet, with reusable Rhai and Jsonnet libraries—rescile allows for defining, governing, and understanding infrastructure with unprecedented clarity, turning complex challenges into simple queries.

This approach creates a single source of truth that unlocks deep architectural insights, automates compliance, streamlines complex operational tasks, and deployments. For a guided visual overview of the whole system, open the architecture landscape.

The Core Loop: From Facts to Verified Operation

rescile builds the digital twin in a simple, declarative, and repeatable process. That graph is then kept honest by an independent observation loop. The facts, architectural rules, governance policies, and output definitions are provided as simple text files, and rescile constructs the intelligent graph.

1. Assets (The Facts): Start with what you have. Define the raw components of your environment—applications, databases, contracts, servers—in simple, human-readable CSV files. This is your ground truth, the foundational “who” and “what” of your world that anyone can contribute to. This data forms the initial set of resources in the graph.

2. Models (The Blueprints): Next, apply declarative architectural models written in TOML or Jsonnet. These are the architectural blueprints that define how your resources connect and interact. They transform the raw facts into a rich, contextual graph by creating new resources, establishing complex relationships, and propagating data across connections. Models can ingest external configuration data from JSON files, and both TOML and Jsonnet models can call shared Rhai libraries (lib/*.rhai) from templates, while Jsonnet models import reusable .libsonnet files the same way.

3. Compliance (The Rules): Next, apply governance and security policies, also in TOML or Jsonnet. These rules automatically mutate the graph to enforce the organization’s standards. This is like applying building codes to your blueprint—inserting firewalls, mandating encryption, and mapping ownership at scale.

4. Output (The Artifacts): Define structured data outputs using TOML or Jsonnet. These declarative templates query the rich, contextual graph to generate actionable artifacts. Far beyond simple JSON or YAML data, the output engine is extremely powerful: it can generate complete executable scripts (bash, Python, etc.), fully formed source code, Terraform variable files, Kubernetes manifests, and comprehensive Markdown or OSCAL compliance reports.

5. Actions (The “Act” Phase): Move from a static model to an autonomous control loop. Using declarative Module Actions, actions are dispatched through a protected queue with sealed secrets and run in sandboxed runtimes (Nix, OCI, or host engines)—applying Terraform, deploying configurations, or running remediation scripts through standardized APIs or directly via the built-in MCP Server for AI agents.

6. Observe & Reconcile (The Evidence Loop): Runtimes and apps submit raw observations via POST /api/v1/observation-inputs. Action-declared normalization turns them into typed, named collections; matching and difference policies compare them against your intent; a decision is recorded; and approved work is dispatched back through the action queue—then verified independently against fresh observations under the original terms. Every receipt, decision, and execution is journaled durably. See Action-owned Observed State.

The result is a comprehensive model of the estate: intent, evidence, and decisions kept distinct, machine-readable, and ready to be queried and integrated into your automation and auditing workflows.

Beyond Intent: Evidence and Decisions

The build pipeline describes what you want. Observed state adds independent evidence about what the environment reports, without rewriting that intent. Action-owned comparisons combine both under each action’s declared policy. The action-only refactor is unreleased: normalization/admission/matching components exist, while production activation, approval/auto dispatch and replacement read APIs/UI remain incomplete.

Keep three things separate: intent is built, evidence is collected, and decisions are derived. An observation can be stale or incomplete; an action’s successful exit is not proof that reality now matches the blueprint.

See Intent, Evidence and Decisions for the visual mental model and the reconciliation loop.

What You Gain: Unprecedented Insight and Automation

This living blueprint isn’t just a diagram; it’s an active tool that empowers the entire organization.

• Get Instant Answers: Answer complex, cross-domain questions in seconds. Instantly trace dependencies to perform impact analysis, attribute costs with precision, and identify every system affected by a vulnerability.

• Automate Governance: Turn audit preparation from a months-long manual effort into a continuous, automated query. Enforce architectural standards and security policies by design, not by chance.

• Drive Intelligent Automation: Use the graph as a single source of truth to generate configurations for tools like Terraform and Prometheus, create targeted remediation tickets, and validate that your deployed reality matches your blueprint.

• AI DevOps & Agentic Workflows: Safely expose your entire infrastructure context and declarative execution tools directly to Large Language Models via the built-in MCP Server.

• Interactive Module Apps: Build and serve custom, graph-aware web applications, visualizations, and self-service portals directly from your models.

Who Are You? Find Your Path

rescile serves several distinct roles. Skip straight to what matches your job — every section is self-contained.