Building an enterprise AI application at OpenAI’s Codex Hackathon

In a few hours at OpenAI’s Codex Partner Hackathon, we built a working enterprise AI application that would typically take months to develop without agentic coding tools. What we learned in the process reveals where enterprise AI is heading, and where the hard work still sits. 

The setup 

In spring 2026, our team joined OpenAI at their San Francisco office for the Codex Partner Hackathon — a closed event for select partners building on OpenAI’s autonomous coding agent. We chose to tackle one of the most persistent problems in enterprise: shortening the path from raw, fragmented information to insights that business teams can act on, while keeping the access governed and auditable end-to-end. 

The result was Meridian, a working enterprise data intelligence application we built from scratch in a few hours. What we learned during those hours says something worth sharing about where enterprise AI is heading, and where the real work still sits. 

The problem we picked 

We chose healthcare data as the test bed. Healthcare ecosystems are unusually fragmented: claims systems, electronic medical records, pharmacy platforms, social factors databases, and call-center logs all live in separate silos, lacking standardized patient identifiers and a shared schema. Industry studies suggest that at least 60% of analytics time in healthcare goes into activities like preparing data, disseminating insights, and less into model building and analysis. 

The underlying pattern is universal, though. Nearly every large enterprise has the same problem shape in different vocabulary; banks, insurers, retailers, and manufacturers all sit on data ecosystems where answering a single business question can take an analyst weeks. 

What we built

Meridian is a three-layer platform that uses Codex as an autonomous engineering agent. Instead of analysts writing pipelines by hand, a plain-language requirement triggers Codex to plan, write, test, and publish a production-grade data pipeline. The three coordinated layers: 

• Agentic data engineering: A user describes the data product they need in natural language. Codex orchestrates a multi-step pipeline, inspects raw data source, profiles quality, standardizes fields, matches records across systems, writes an audit log, and publishes the final product. Every write operation is previewed in dry-run mode before anything is applied to production data. 
  
  

• Governed AI chat: Once data products are published, business users, care managers, analysts, and operations staff can query them through a conversational interface. The agent can identify cohorts, generate risk explanations, suggest outreach plans, and produce charts on demand. Every response surfaces an explainability panel showing the model’s reasoning. Sensitive fields are masked dynamically based on who is asking. 
  
  

• Role-based collaboration: Different organizational roles see different things. A care manager sees full member detail; an analyst sees a masked view appropriate to their function; a quality reviewer sees only aggregates. Every query is logged to a tamper-evident audit trail. 

The whole platform runs on a composable tool architecture using Model Context Protocol (MCP), an open standard that lets AI agents discover and call enterprise tools securely. The agent is not hardwired to any one stack; the same pattern can be pointed at any compliant set of enterprise systems.

[Architecture diagram — see HTML mockup; Caption: “Meridian architecture, simplified — from natural-language requirement to governed end-user access.”] 

Three things became very clear

• Agentic coding tools have made a real leap

The developer experience has moved from chat-based assistants to AI-augmented code editors to dedicated agentic environments where an agent can plan, write, test, and iterate across multi-step workflows with minimal supervision. Multi-branch agentic workflows, sandboxed execution, and shareable plugins are quickly becoming foundational for serious engineering work. 

The most extensive part of an enterprise project, translating a requirement into working, tested, deployable code, is now something a well-directed agent can do in a fraction of the time it used to take. 

• Agents need clear direction, not just capability

The tools are powerful, but agents without precise direction tend to produce volume rather than value. Throughout the hackathon, the bottleneck was rarely what Codex could do; it was articulating what we needed it to do. 

As agents become more capable, clear thinking up front matters more, not less. When a requirement is vague, the agent produces a lot of work that must be redone. A few minutes spent clarifying what “good” looks like, drawing on the product owner’s domain knowledge and the engineer’s judgment, saves hours of rework later.

• Enterprise-scale agent collaboration is the next frontier

Meridian demonstrates what one agent can do inside one organization’s data environment. The harder question, the one we did not solve at the hackathon, is what happens when multiple teams each have their own agents, each operating on their own data and workflows. 

How do those agents securely discover one another across organizational boundaries? How do they share context without leaking sensitive information? How do you maintain a coherent audit trail across multi-agent operations spanning several departments? This problem is being actively worked on, but few robust solutions exist today, and that gap is where the next wave of enterprise value will come from. 

What this means for enterprise AI strategy 

• Direction has become the differentiator. The technology to build prototypes in hours is here. What separates organizations now is whether they have clear business hypotheses, well-governed data, and the technical expertise to validate the agent's output. Without those foundations, agentic tools mostly accelerate the production of things that shouldn’t have been built. 
  
  

• Governance becomes an enabling capability. In Meridian, role-based masking, audit logging, and human approval gates are exactly what make it safe for business users to interact with the system at all. Organizations that design governance into the agentic stack from day one tend to move faster than those bolting it on later. 
  
  

• The hard work has moved upstream. When pipeline construction takes minutes, the bottleneck becomes problem framing, data product design, role and access policy, and operational integration. These are the activities where deep cross-functional judgment is irreplaceable and the value of an experienced enterprise AI partner is most visible.

Potential impact of the solution

The prototype is too nascent to have been measured against a production baseline. Based on similar platforms our teams have shipped, the impact at enterprise scale tends to fall in familiar ranges, significant compression of pipeline build times, meaningful gains in time-to-insight for business teams, and noticeable reductions in the volume of analyst-mediated requests. Meridian is designed to land in those same ranges. 

Conclusion

We built Meridian in a few hours. Deploying something like it at scale, with real data, real compliance requirements, and real organizational complexity, is a different order of work. That is where the engagement moves from “writing the code” to designing the conditions under which the code is worth running: framing the right problem, building the right data products, defining the right access policy, and integrating with the workflows that already exist. 

The distance between an idea and a working product is shrinking fast. Closing the remaining gap is where the value of an experienced team becomes most visible.