Grounded, Honest and Continuous
Most automation drifts with time β people move on, logic gets changed, alarms and overrides pile up, and eventually no one has a verified picture of what it actually does. Daritas reads the real automation code and rebuilds that picture claim by claim: every claim cited to its source and graded by how it is known, the unknowns disclosed instead of papered over, reviewed and signed off by a named automation engineer, and kept current as the system changes.
Creates your account. We open it by hand β usually within a day, and nothing is charged.
Just your email, no account and no login β we write when there is something worth reading.
Keeping the plant running well is a shared interest. The case for Daritas just looks different from the corner office and from the plant floor.
Unplanned downtime, stalled modernisation, and expertise walking out the door are business risks with real price tags. Daritas rolls your automation up into one verified picture β what's sound, what needs attention, and where the risk sits β so you can put money where it protects production.
Start with what it does for the business βπ οΈFor automation engineers & floor managersYou have enough to keep running without adopting a new tool. Daritas reads the automation code you already have and hands back a verified picture of it β every claim cited to its source, unknowns declared, signed off by a named automation engineer. Nothing to install on your control network, nothing new to maintain β and if you're the one who wants every interlock mapped, the full evidence trail is yours to dig through.
Start with how it treats your code βWhichever door you take, it isn't a one-off report β Daritas follows your system through change, version by version, and keeps the picture current as the plant evolves. See the living evidence loop β
Engineers trust it because every claim is grounded in the real code. Leadership backs it because it de-risks change, protects uptime, keeps critical knowledge in-house, and rolls the whole estate up to a clear picture of what's sound and what needs attention.
Every system across your sites, rolled up for leadership β what's sound, what needs attention, and where the risk sits. The executive view of your automation.
Know exactly what to preserve, change, or retire before you touch production or brief an integrator β so upgrades don't turn into expensive surprises.
Undocumented logic and forgotten overrides are how production stops for reasons no one can explain. A verified baseline removes the blind spots.
Retiring engineers and rotating contractors take the understanding with them. Daritas captures it as a durable, evidence-backed asset β evidence on demand for handovers and audits.
Ask it anything and it answers. Knowing which questions matter is harder β and your own automation engineers have spent careers learning exactly that. What they haven't had is the countless engineering hours it takes to move that judgment from a brain to a keyboard: turning it into a repeatable, evidence-disciplined method an analysis can run on β that is what Daritas is. So when an experienced engineer is heading for the door, the best use of the months you have left with them isn't building an analysis workflow in an AI workspace β it's answering the sharp questions our assessment asks, so what they know becomes owned, confirmed knowledge of your installation before it drives away. And when a finding needs fixing, the assessment can brief the AI in your own engineering tool β the verified context it cannot see from the code alone: what the function is for, which interlocks the fix must not break, what to re-verify afterwards. Not a second AI to argue with yours β the evidence layer above it, giving the one you already use verified context and explicit uncertainty bounds, so acting on its answers carries less risk.
The answers are cheap now. The questions are the expertise.
Some things were never written down: why a setpoint is what it is, which alarm everyone learned to ignore, the workaround from the 2019 retrofit. Where the sources can't settle a behaviour, Daritas doesn't fill the gap with a plausible sentence β it raises the question in plain language, quotes the line that prompted it, and names who is likely to know: the controls engineer, the operator on nights, the integrator who built it, the vendor's support desk. Bring your team into the portal and the open questions sit there against the model, one per behaviour waiting on a person. Every answer is recorded against the claim it explains, attributed to who said it and when, and kept as testimony β a separate tier from what the code proves, never laundered into fact. We ask the few questions that would change the model, never a questionnaire.
An unanswered question stays a stated unknown β never a guess.
Under the hood: nothing is asserted without inspectable evidence β every claim grounded in its source, graded by how it is known β and in the expert lane, signed off by a named engineer.
Thousands of lines of ladder logic and structured text, surveyed and distilled into a model you can actually read β in days, not the months a manual reverse-engineering takes.
In the expert lane, a named, accountable automation engineer reviews the model and attests to its claims within a stated scope. Not a black-box AI summary β a result a human stands behind.
Daritas reads the logic itself β across controller families, IEC 61131-3 languages, and embedded control code β not a single vendor's format. Support depth varies by format, and every assessment states what was fully parsed and what was not.
Every claim links to the evidence that supports it β source-derived claims down to their source locations β and the model follows the system version by version, instead of going stale in a drawer.
Standing at the machine with an alarm you do not recognise? Ask, and get an answer drawn from that systemβs assessed model with the evidence behind it β scoped to the machine in front of you, because the same code means different things on different systems.
As AI starts to explain, change, and advise on production systems, it needs trustworthy context β not guesses. Daritas is the verified evidence layer: it shows what the evidence establishes about your system today, flags what's unknown instead of inventing it, and shows what changed after an AI-assisted change. When AI touches your automation, you keep the evidence trail.
Read-only. Advisory. Never a control path.
Every assessment comes with the Advisor: ask in plain words and get an answer drawn only from that system's verified model, each source quoted with its review status and confidence. It is not a chatbot with your documents in the prompt β retrieval is deterministic, the model only phrases what was actually found, and when the evidence does not cover your question it says so instead of filling the gap.
The half of a Q&A engine nobody builds: the questions that go the other way. Where the evidence runs out, the engine raises a question instead of guessing and it is put to whoever holds that knowledge β through our own chat, email, SMS, or a phone call that tells them one is waiting. The answer becomes evidence with their name and the date on it. Nobody answers in time? The gap is recorded as a labelled assumption, and it stays labelled β that is the opposite of a confident sentence you cannot trace.
Answers are kept against the system, so the question asked at three in the morning is still there next month β and the person who asked can share it with their organisation, turning one night's answer into something the whole team can find. Ask on the phone at the machine, read it back at the desk.
Read-only. Advisory. Never a control path.
Every deliverable carries its grade β machine-generated or engineer-reviewed β and the label is never blurred. The reviewed grade is worth paying for because it is attributable β bound to a named reviewer, a defined evidence set, and a stated scope.
An AI-only pass at machine speed and machine price β for breadth, orientation, and the everyday questions that don't warrant an engineer's time. Same grounding discipline, honest label: no engineer has reviewed it, and it never pretends otherwise.
A qualified automation engineer verifies the model against the evidence, resolves ambiguities, and signs off by name. For the occasions where accountability matters: safety, compliance, handover, the modernisation decision.
Same customer, both lanes β breadth from the machine, accountability from a name.
Read the Assessment Standard β what we assert, and how to check it β
Your installation changes: code gets modified, systems get modernised, people move on. Daritas keeps the understanding current. Every change gets a change-impact review, every unknown becomes tracked work, every baseline is versioned and signed off β a PlanβDoβCheckβAct loop that turns a one-time assessment into a durable record, current to the latest accepted baseline: when a new version lands, affected claims are marked stale until their evidence is renewed.
That's the Ξ΄ in our mark β the engineer's symbol for change. An assessment done once tells you what your system was; used continuously, Daritas shows every delta: what changed between versions, with the evidence for it.
Portable markdown β yours to keep, even without the subscription.
Real installations are rarely a single program. Daritas assesses multi-unit systems as one composed model β each unit read at the depth it needs, and every connection documented as an Interface Catalog (ICD): between units, and outward to SCADA, field I/O, and neighbouring systems. Proven behaviour and design-level structure are reported as separate tiers, so you always know which claims carry evidence.
Interfaces evidenced in the code β runtime behaviour marked unverified until corroborated.
Three stories from industry and one from the Moon β what an evidence-backed model does in practice.
Twenty years of recipe logic, recovered before the integrator retires.
βπ’Every interlock in every air-handling unit, cited to the code that proves it.
ββοΈA verified behaviour baseline for machines shipped fifteen years ago.
βπAsk Daritas about the most famous error code ever flown. The fun one.
βRuns on your floor, with your own AI β a local AI model, or your API key over one controlled connection. The engine does the reading; in the expert lane a named engineer reviews the result and attests to its claims within a stated scope β an evidence-backed system model you can inspect, question, and keep current as the system changes.
Daritas runs inside your own network β point it at your control program (a PLCopen XML export or the project source). The deep reading uses an AI: your own local AI model, your API key over a single controlled connection, or β for fully air-gapped sites β the deterministic engine alone, with the reduced depth honestly marked. Your source never has to leave your site.
The engine surveys the code, condenses it to its logic essence, and extracts the behaviours it can identify β each tied to the exact source that supports it, with coverage disclosed: what was read, what was out of reach, what stayed unknown. Bring your own AI: a local AI model or your own API key, so even the reading stays under your control.
A qualified automation engineer checks the model against the evidence, resolves ambiguities, and puts their name to it.
Get an interactive model you can navigate, plus clean document exports for your own meetings, audits, and handovers.
Built for control rooms that can't send their source anywhere. You stay in control of what gets read, what gets shared, and what you keep.
The engine runs offline, inside your own network. Your control-system source never has to leave your site.
Use a local AI model or your own API key β or, for the strictest sites, run the deterministic engine with no external AI at all.
Every claim links to the evidence that supports it, and reviewed models carry a qualified engineer's sign-off. Nothing is asserted without evidence.
Only the evidence-backed model leaves, and only if you choose. It exports as portable markdown β yours to keep, even without the subscription.
Review and redact before anything is shared, and optional obfuscation keeps proprietary logic out of what you hand on. Daritas never uses your source to train models β and with a bring-your-own provider, the training terms are the ones in your own contract.
In the cloud, your system model is locked to your organisation β row-level security, access by invitation, and access tokens stored hashed.
If you deliver and maintain automation for others, Daritas is your leverage β assess and verify your clients' systems with your own team, under your own brand, across every site.
Hand over the evidence-backed model and reports as your own team's work β the Daritas branding is removable.
Verify with your own engineers β juniors do the volume, a senior signs off. Nothing leaves your client's site.
Switch between client sites and see the whole estate β one login across all the organisations you serve.
Start with one system. Buy the baseline once, keep it living with a continuity plan, and expand across your estate β priced by scope and criticality, never per seat.
Each assessment is scoped and quoted before you pay β you see the price after the scoping preview, and nothing starts until you confirm. Pricing confirmed on enquiry during early access.
A fast, high-level map of one system: its main components, structure, and most visible risks. The cheapest way to decide where to dig.
Every identified behaviour grounded to its source, with components, dependencies, and a risk picture β plus a coverage report of what was analysed, what was not, and the open unknowns. The core deliverable for a system you depend on.
A full model plus a deeper, adversarial review β does the evidence really support each claim, do claims contradict each other, and what is obsolete. For audits and high-stakes systems.
Verification against a replacement, a specification to rebuild from, or runtime corroboration. For replacement, modernisation, and verification programmes.
Begin with a scoped Evidence Sprint β a narrow, fixed-price slice that proves the value and credits toward the full assessment. Then own the baseline at a fixed, quoted price per system. No subscription required for your first model.
Subscribe to keep the model current as the system changes β re-runs and diffs that keep it the system of record instead of letting it go stale.
Add more systems, sites, and variants over time β and get one comparable overview across your whole portfolio.
Every assessment builds a structured, queryable model you own. Reach it via API, an MCP server, or a documented export β so your system knowledge lives inside your own IT, your own tools, and your own documents.
Every delivered system model lives on as a queryable dataset. Ask in plain language β "which interlocks stop the supply fan?" β and get structured answers with source citations, not a PDF page number.
Connect Claude, Cursor, or your own AI agent straight to your system model. Let it look up behaviours, trace dependencies, and check claims against the evidence. With a local AI model the loop stays inside your network; with a cloud AI client, tool results reach that provider under your contract.
Every assessment exports in portable form β Markdown, Word, PDF, and a structured export of the model itself. No lock-in: the understanding of your own plant leaves with you, readable without us.
Daritas isn't a black box. Every reviewed model is verified and signed off by a qualified automation engineer who puts their name to it β because in industrial control, accountable human judgement beats a confident guess. We're building a global network of those engineers, with layered AI and peer checks that reduce the risk of a single weak review. For sensitive systems, an optional obfuscation layer strips your proprietary names before anyone sees the code, then restores them in the delivered model β your logic is reviewed, your proprietary names stay home.
Join the reviewer network