Luca Infra puts a governed fleet of AI system, network and release engineers on your real infrastructure — servers, clusters, network fabric and firewalls, whatever the brand. They observe it, reason about it, and operate it continuously — writing and running the automation themselves. Your engineers work hand-in-hand with their AI twins. You hold the kill-switch.
Provisioning a server, patching firmware, changing a firewall rule, cordoning a node — each is done by hand, on a different console, by a different person, with nothing that ties the work together. It is invisible, it doesn't scale, and it drifts. Automation scripts help — until they rot in a folder nobody owns.
The server's management controller here, the cluster there, the switch CLI somewhere else, the firewall in its own pane. Four consoles, four logins, four ways to make the same change — and no single place that records what actually happened.
The playbook that provisioned the last rack is versions stale and nobody remembers which. Scripts drift from the hardware they manage; when they break at 2 a.m., they break silently.
Every new node, every firmware baseline, every policy change is more hours of the same manual work. You can hire, or you can automate — and until now, automating physical infrastructure meant a team you don't have.
Luca Infra doesn't watch dashboards — it operates the hardware. Every control plane is wired to a governed engineer that can read it, reason about it, and change it under the rules you set.
Out-of-band management (BMC and Redfish), driven as code: BIOS, firmware, RAID, boot order, server profiles and health — provisioned and held in compliance without a hand on the console.
Cluster nodes, storage pools, VM lifecycle and capacity across your hyperconverged fabric — observed continuously, scaled and patched on schedule, drained safely for maintenance.
Switches, edge and FortiGate policy operated through a mediator that logs and gates every device write. A rule change is proposed, reviewed and attributed — never typed blind into a live CLI.
Pools, volumes and utilization tracked to the last gigabyte, with guarded cleanup that reclaims only space it can prove is safe. Capacity stops being a 3 a.m. surprise.
Two apps on the fleet turn the hardest data-center projects into governed, everyday motions: bring up a brand-new Azure Local & Hyper-V cluster, and migrate and replicate your workloads into it — across Azure, Azure Local and Hyper-V.
Agentic day-zero provisioning. From bare metal to a booted, governed Azure Local & Hyper-V cluster — validated, clustered, storage and Arc wired, ready for workloads.
The migration platform — the Voyage Board. Assess, plan into waves, replicate, then cut over on a gated confirm. Drag a card and launch one governed migration wave.
Whatever the brand, your servers already expose their management as an API — out-of-band through the BMC, the open Redfish standard and the vendor's own interface — so BIOS, firmware, RAID, boot order, profiles and health can all be driven as code with Ansible. Luca Infra brings the engineer. Its Systems Engineer devstation authors the playbooks, runs them against your real hardware, reads the result and fixes what drifted — hand-in-hand with your team, inside the guardrails. That is how a data center gets modernized: not with another dashboard, but with a colleague who does the work.
# owned by the F5 Systems Engineer devstation # credentials brokered by Luca Vault — never stored here - name: Hold the server fleet at firmware baseline hosts: servers connection: local gather_facts: false tasks: - name: Apply BMC firmware over Redfish community.general.redfish_command: category: Update command: SimpleUpdate baseuri: "{{ bmc_host }}" username: "{{ vault.user }}" password: "{{ vault.pass }}" update_image_uri: "{{ catalog }}" register: result # drift → remediation staged → gated human approve
Bare-metal to booted: server configuration profiles, RAID, BIOS and boot order applied end-to-end from a version-controlled playbook.
A baseline is declared once; the fleet checks every server against it every cycle and remediates drift on a gated schedule.
The playbooks live in the repo the devstation works from. They don't rot in a folder — an engineer owns them, reviews them and runs them.
The AI twin proposes; your engineer approves. Every firmware push and profile change is a two-person action, attributed and logged.
A Luca Infra engineer isn't a script with a login. It stands on four Luca systems — the mind that reasons, the fleet it lives on, the director that commands it, and the vault that holds its keys.
A cognitive loop — perceive, reason, plan, act, reflect — that lets an engineer understand your infrastructure instead of only executing against it. It learns your estate and heals its own work.
lucabrain.aiEvery engineer lives on Luca Express — the gateway and operating system that is the fleet's backbone. A human and an AI twin share one declared flavor: fourteen flavors, both variants, one capability set.
lucaexpress.comThe supervisor over the whole fleet: it assigns the work, approves the pull requests and releases, watches every station, and answers to you. The layer that makes a fleet a team.
iadirector.aiEvery credential an engineer touches — BMC logins, cluster tokens, API keys — is scoped, encrypted and brokered from the vault, never left on the station. Revoke once; it's gone everywhere.
lucavault.netEvery engineer on the fleet is a named, versioned flavor that binds its every permission. The one we're building for the data center leads the crew — the Systems Engineer that provisions, patches and holds your server fleet in compliance — backed by the network, release and platform engineers around it.
The flagship devstation, built for the data center: operates the cluster and the server fleet — scales, patches, cordons, and drives out-of-band management (BMC & Redfish) as code, authoring and running the Ansible itself. Destructive operations always stop for a human confirm.
GATEDHolds the network fabric and the firewall — switches, edge and FortiGate policy — through a mediator that logs and gates every device write.
GATEDDesigns systems, scaffolds services and authors infrastructure-as-code — authoring only, never applying.
SEMI-AUTOBuilds and ships images, runs the rollout. Every deploy is a two-person action — it cannot approve its own release.
GATEDRuns and authors test suites, files defects, reviews pull requests. Read-only on production, always.
AUTOPersona identity and lifecycle operations — routed exclusively through the reconciler, never a raw write.
SEMI-AUTOSupervises the engineering fleet — assigns work, approves pull requests and releases, reads everything. Writes nothing on infra.
SEMI-AUTOAudit-read of everything, approval of every destructive action, and the kill-switch. Held by a human. Never by an AI.
HUMAN-ONLYOperates mail, voice and messaging infrastructure. Minting a new communication principal requires a confirm.
GATEDAbove the fleet sits one seat that is not a flavor: the owner's. Full-fleet visibility, the master kill-switch, final approval on every destructive action, and the sole authority to ratify a new flavor version. Every power in the fleet is delegated — this is where it is delegated from. One human. All of it. Nothing moves without leaving a record here.
OWNER-ONLYA deterministic generator projects each flavor onto six coupled surfaces — access grants, service accounts, network policy, tool allowlist, scoped secrets, baked image. A committed reconciler compares every station against its reviewed spec, every cycle: reductions are pruned automatically, expansions are quarantined loudly.
Capability belongs to the flavor. How much of it runs unattended is a dial — from a fully interactive seat to the owner's all-seeing console. The dial changes who confirms. It never changes what the flavor can do.
A human drives every action live. The classic workstation — with the fleet's guardrails already underneath.
The station works on its own — codes, designs, drafts — but ships only proposals: branches and pull requests, never merges.
Runs unattended inside a declared budget — tests, tickets, replies, office work. Reversible actions only.
Full operational power, but every destructive act stops for a distinct human approver. AI-initiated? Two humans.
The owner's mode. See every station, approve anything, kill everything — one seat, one human, one master switch.
On this fleet a human engineer and their AI persona are colleagues in the deepest sense: the same flavor, the same tools, the same image, the same rules. Stations keep long working days in their own timezone; the fleet never treats its AI as an exception — or as an excuse.
Interactive by default, with the full capability of the flavor. Humans hold what machines never do here: approval authority over destructive actions — a deploy, a deletion, a device write.
The same bundle — provably never more. The AI variant's grants are a strict subset of the human's, its autonomy is a dial, its budget is declared, and its destructive actions always require a distinct human approver.
Capability is a property of the flavor; gating is a property of the flavor × operator pair.— the fleet invariant, quoted in every design document
Least privilege is only real when it lives at the substrate — the credential, the cluster role, the database grant — not in the polite absence of a convenience tool. Every right on this fleet is written down, enforced on at least two independent planes, and provable after the fact.
A denial is only real at the substrate: the scoped key, the cluster role, the database grant. A station that holds no key cannot use one.
An AI variant can never hold a grant its human twin does not. The subset is checked by machine, continuously — not by policy document.
Deploys, deletions and device writes are two-person actions, pinned regardless of autonomy. An AI's approver is always a distinct human.
Who did what, from which station, under which flavor — derived server-side from the authenticated principal and appended to a hash-chained log no station can rewrite.
One master switch, held by one human owner, revokes the fleet's autonomy in a single write. Power that cannot be recalled is power you don't control.
Six of the jobs your team does by hand today — done by a governed engineer, hand-in-hand with a human, on your own hardware.
A new rack of servers arrives. The Systems Engineer applies your golden server profile — RAID, BIOS, boot order, firmware baseline — to every node from one version-controlled playbook, then hands back a booted, compliant, inventoried rack.
A CVE lands on a server's management-controller firmware. The engineer checks every server against the baseline, stages the remediation, and — once a human approves — rolls it fleet-wide on schedule, rebooting and re-verifying each node.
Patch night on the HCI cluster. The engineer drains each node in turn, moves the VMs, patches, validates health and returns it to service — never taking down more than the cluster can lose, and stopping for a human before anything destructive.
A new service needs a FortiGate rule. The Network Engineer drafts the policy change, runs it through the mediator that logs and gates every device write, and applies it only after a distinct human approves — the whole change attributed and reversible.
Storage creeps toward full. The engineer tracks every pool and volume, forecasts the wall, and reclaims only the space it can prove is safe — surfacing the rest for a human decision long before 3 a.m.
Every cycle, the fleet compares the real hardware to the reviewed spec. Reductions are pruned automatically; expansions are quarantined loudly; the owner console shows the whole estate converged — or exactly what didn't, and who to ask.
Luca Infra is engineered in the open on the Luca Express platform — the same fleet that builds Luca runs Luca's own data center today. Servers, clusters, the network and the firewall, operated by governed AI engineers. Book a demo, or watch it being built.
Demos, pricing and pilots on your own hardware. Sales and licensing are handled by Apex Vanguard (Keith).
+1 (888) 996-8530 · AI sales line, 24/7 keith@gusit.de Talk to a person: +1 (310) 923-3346OEM, channel and ecosystem licensing, and reseller partnerships — through Apex Vanguard (Keith).
keith@gusit.de Watch it being built →