EVA 1.0 – Safe AI Event Production

EVA turns scattered emails, contracts, technical riders and tasks into one safe, auditable workflow for live event production — with human approval at every critical step.

Comment

Inspiration

Live-event production is exciting on stage, but behind the scenes it is often fragmented and difficult to manage.

Contracts arrive by email. Technical riders, rooming lists and attachments are stored in different folders. Responsibilities live in spreadsheets, while deadlines and production tasks can become disconnected from their source information.

I have worked in live events, cultural projects and organizational development for more than four decades. My experience includes producing 2,500 events for Switzerland’s National Exhibition, Expo.02, running an event-management agency, leading tourism and cultural organizations, and working today with Kulturfabrik Industrie36 and gambrinus jazz plus.

I have spent most of my working life making complicated projects possible — from intimate jazz concerts to a national exhibition. The scale changes, but the basic challenge does not: the right information has to reach the right person at the right time.

I love what happens on stage. But I also know that a concert only feels effortless when many people have worked precisely before the first note is played.

EVA grew from a practical question:

How can AI help small cultural organizations manage complex event productions without taking responsibility away from people?

Why the name EVA?

EVA stands for Event-Vorproduktions-Automation — German for event pre-production automation.

The name also refers to Eve and the Tree of Knowledge. For me, that symbolism fits the project: important knowledge should not remain hidden across emails, contracts, folders and spreadsheets. It should become visible, understandable and useful.

But access to knowledge is not the same as handing over responsibility. EVA helps people make informed decisions while keeping those decisions firmly in human hands.

What EVA does

EVA is a human-controlled and auditable production system for live events.

Its broader architecture connects four operational layers:

  1. Source intake
    Event-related emails, attachments, contracts, technical riders and rooming lists can be assigned and filed into the correct event workspace and document folders.

  2. Single-event production workspace
    Each event has one structured master file as its single source of truth, together with contacts, responsibilities, deadlines, tasks, subtasks and an event-specific dashboard.

  3. Multi-event index
    A refreshable event overview provides fast access to every active event workspace and its current production status.

  4. Management cockpit
    A future management view will consolidate deadlines, critical issues, responsibilities and open tasks across all active events.

The goal is to connect source information, operational work and management oversight without creating parallel sources of truth.

What the Build Week prototype demonstrates

The public Build Week browser prototype focuses on EVA’s single-event workspace.

It demonstrates:

  • a clear production overview;
  • event facts, deadlines and responsibilities;
  • a visible distinction between seating type and seating note;
  • filterable production tasks;
  • confirmed completion and reopening of tasks;
  • a user-friendly backline subtask interface;
  • controlled edits using PLAN → APPROVE → APPLY;
  • exact before-and-after previews;
  • a transparent audit trail;
  • a safe local reset using fictional data.

The prototype is completely self-contained and runs in a current desktop browser without installation, login, API key, database or server.

It stores demo changes only in the browser’s localStorage and makes no AI calls at runtime.

Why human control matters

Event production involves real artists, contracts, travel arrangements, technical requirements, financial commitments and fixed deadlines.

In live production, “almost correct” is often not good enough. A missed detail can mean the wrong hotel room, a missing instrument, an avoidable cost or unnecessary stress for people who are already working under time pressure.

A system that silently changes, deletes or “repairs” information would create unacceptable risks.

I am curious enough to try new tools, but experienced enough not to hand over responsibility to them.

EVA therefore follows explicit operating principles:

  • no automatic deletion;
  • no silent overwriting;
  • read-only analysis before productive changes;
  • human approval before consequential actions;
  • changes scoped to one event and one entity;
  • before-and-after values for planned changes;
  • an audit trail for every approved action;
  • clear STOP rules when results are uncertain.

The goal is not autonomous event management.

The goal is safe and auditable human–AI collaboration.

How it was built

The underlying EVA production concept existed before Build Week and grew from a real operational workflow.

I did not begin EVA because I wanted to become a software developer. I began because I was tired of solving the same avoidable coordination problems again and again.

During OpenAI Build Week, I used Codex and GPT-5.6 to create a new, anonymized and reproducible browser prototype.

I brought the questions, the operational experience and the insistence that every important step must remain understandable and controllable.

I acted as:

  • domain expert;
  • product owner;
  • workflow architect;
  • safety-rule designer;
  • tester and final decision-maker.

Codex and GPT-5.6 helped:

  • translate the product requirements into a technical plan;
  • implement the HTML, CSS and JavaScript application;
  • create the local data and state model;
  • implement task and subtask workflows;
  • build the PLAN → APPROVE → APPLY interaction;
  • add audit and recovery behavior;
  • test file-based browser execution;
  • review privacy, accessibility and robustness;
  • identify and repair two concrete safety issues;
  • prepare the README, build log and public release.

The main Codex thread was independently reviewed several times. The final review reported no findings.

Challenges

I have always preferred practical systems that people can actually use over impressive ideas that fail in everyday work.

The hardest challenge was not generating code. It was defining when automation must stop.

One review identified a confirmation-dialog issue where an outdated dialog result could potentially trigger an action after closing with Escape. Another found that structurally incompatible localStorage data could prevent the demo from loading correctly.

Both issues were corrected and tested:

  • only the explicit confirmation button can authorize an action;
  • Escape and Cancel remain non-destructive;
  • incompatible demo state falls back safely;
  • only EVA’s own localStorage key may be replaced;
  • unrelated browser storage remains unchanged.

Other challenges included:

  • keeping one authoritative event identity;
  • separating source data from generated views;
  • safely handling user-entered text;
  • maintaining file:// browser compatibility;
  • making complex production details understandable to non-technical users;
  • communicating a much larger system through a focused single-event demo;
  • protecting confidential artist, contract and contact information.

Beyond the single-event demo

The broader EVA architecture also includes:

  • semi-automatic assignment and filing of event-related emails and attachments into the correct event workspace;
  • structured filing of contracts, technical riders, rooming lists and other source documents;
  • future AI-assisted extraction of relevant information from emails and attachments;
  • human review before extracted information is written to the event master;
  • a refreshable multi-event index with direct access to all active event workspaces;
  • a future management cockpit covering deadlines, responsibilities, critical issues and open tasks across all events.

These functions are part of the broader product direction and are not presented as completed features of the public browser prototype.

About the builder

EVA was initiated by Andreas B. Müller, a Swiss live-event producer, cultural project leader and communication professional with more than four decades of experience.

His background includes running an event-management agency, leading tourism and cultural organizations, managing major projects, and serving on the event directorate of Switzerland’s Expo.02 with responsibility for the production of 2,500 events.

Today, he helps lead the program and projects of Kulturfabrik Industrie36 and serves as president and communications lead of gambrinus jazz plus.

He is not a traditional software developer.

For EVA, he turned operational experience into product requirements, safety rules and acceptance criteria, using Codex and GPT-5.6 to build and review a working human-controlled prototype.

At heart, he is a practitioner. He values ambitious ideas, but trusts them only after they have survived real-world use, careful testing and honest review.

What I learned

I learned that the quality of an AI-assisted operational system depends as much on its rules as on its code.

Clear definitions of the source of truth, approval gates, scoped changes, audit trails, fallback behavior and manual testing are essential when software interacts with real organizational data.

AI is not valuable to me simply because it can act quickly. It becomes valuable when it helps people work more clearly, reliably and responsibly.

The experience also confirmed something I have learned throughout my professional life: good tools do not replace people. They give people a better basis for making decisions.

I also learned that AI can enable a domain expert to act as product owner, tester and workflow architect — while remaining honest about which functions are demonstrated, which already exist in a private operational context and which remain future development.

What’s next

The next steps are:

  • test the complete event-creation workflow with a real new event;
  • migrate existing active events into the updated structure;
  • connect the user-friendly subtask interface to the production master model;
  • implement safe task completion in the productive single-event dashboard;
  • complete the refreshable multi-event index;
  • consolidate unresolved and legacy production tasks;
  • expand email and attachment intake;
  • develop human-reviewed extraction of event-relevant source information;
  • build the cross-event management cockpit.

My ambition is not to build the most autonomous system. It is to build one that a small team can trust on a busy production day.

The long-term vision is a practical production copilot for small venues, festivals and cultural organizations:

AI helps organize the complexity. Humans remain responsible for every consequential decision.

Built With

Share this project:

Updates