Should all enterprise code and workflows become natural language? G5 Labs thinks so, and its new G5 platform does it for you

AI coding agents are rapidly becoming the predominant authors of enterprise software (at Anthropic, they're already up to 80% of all production code shipped). While this may improve speed and productivity, it leaves enterprises with a new, arguably even more vexing problem: how to ensure their many AI agents working together don't do so at cross purposes, that is, that they don't write code that conflicts with one another, the enterprise's current operations, or the human developers overseeing it all?

G5 Labs, a new startup founded by decorated Massachusetts Institute of Technology (MIT) computer science professor Tim Kraska, is emerging from stealth today with $14 million in seed funding to solve this issue decisively, and further, to futureproof its enterprise customers as they adopt any subsequent, even more powerful artificial general intelligence (AGI) agents.

The company's first product, G5, is a secure, cloud-based web platform that turns an enterprise's business requirements, architectural decisions, policies and other human intent into what the company calls a system ontology — a structured semantic graph that informs the entire system, including the humans and AI agents, of what everyone's intentions and goals are.

“Our core hypothesis was that we try to make natural language the new source code of the tool," Kraska told VentureBeat in an exclusive interview. "Natural language, with some structure on top—what we call the system ontology—actually becomes the new source code, and then the source code, which could be Python, Rust, or something else, is derived from that.”

The company's pitch sounds, at first, like the increasingly familiar idea of spec-driven development: write down what the software should do, hand the specification to an AI agent, and let the machine write the implementation.

There is a conceptual resemblance to Palantir’s Ontology, which gives enterprises a semantic model of their operational world. G5 is attempting something analogous for the software-development lifecycle: creating a semantic model of what an application is supposed to do, why particular decisions were made and how those decisions map onto the underlying code.

But G5 Labs is making a substantially more ambitious claim. It does not merely want natural-language specifications to precede the code: It wants the semantic representation to remain synchronized with the implementation, to mediate conflicts between changes, to encode organizational policies, and ultimately to become the layer from which software can be regenerated.

"This isn't just better prompting — it's a new abstraction layer," Kraska added in a press release provided to VentureBeat. "With G5, natural-language intent becomes the source code itself: compilable, mergeable, diffable, and governable, the way high-level languages once replaced assembly. For the first time, it puts software in the hands of the whole organization, not just developers."

For enterprise buyers, that distinction is the entire case for G5 — and also the part that deserves the most consideration against their legacy or current AI implementations.

From an AI coding tool to a system of record for intent

Kraska's bonafides are numerous. In addition to teaching computer science at MIT's reknown Computer Science & Artificial Intelligence Laboratory (CSAIL), he also previously co-founded Einblick Analytics (whose team was acquired by Databricks in 2024) created Learned Indexes at Google Brain, and served as a director of applied science at Amazon.

He said the research behind G5 Labs began roughly two years ago with a question: What should software development look like if AI eventually writes most or all of the implementation?

G5 Labs' answer is a bidirectional system. Existing software can be "uplifted" from source code into the ontology; human users and agents can then reason over that semantic representation; and G5 can drive an implementation back down into conventional languages and frameworks.

G5 runs its bidirectional compiler over the existing codebase/specifications to construct an initial semantic graph, extracts/organizes workflows and design decisions into ontology nodes, then has humans review that representation before driving changes back into code.

The company says the ontology is broader than a feature specification. David Chang, G5 Labs' COO and a fellow former Googler and former Global Go-to-Market Lead of Amazon's Nova AI models, told VentureBeat that G5 captures the data model, business rules and workflows, as well as company-wide policies covering areas such as security, GDPR, infrastructure and coding standards.

"Each ontology node is written in natural language and linked to the code that implements it, so every line of code is traceable back to a requirement," Chang said. "The G5 system constantly audits the ontology for consistency and the code for adherence to the ontology."

G5's website states that users can "change the intent, and the code rewrites itself. Change the code, and the ontology learns. Every line traceable." In an example shown on the site, generated source code carries trace metadata pointing back to a particular ontology concept and revision.

That architecture could matter as the volume of AI-generated code begins to exceed what humans can meaningfully review line-by-line.

“If one of your engineers submits a 100,000-line code change, how do you deal with that?" Kraska noted. "One of our engineers actually just submitted, in one week, a 300,000-line code change to the platform. You just need new mechanisms to deal with that. The old ways simply don’t work anymore.”

In the product materials and a live demonstration shared with VentureBeat, G5 showed a "Diff Graph" connecting human chats and documents to ontology concepts, architectural components and individual source files.

“We try to develop the tooling for what we call the post-developer era: what happens after developers no longer write code, no longer read the code?" Kraska said, with a gleam in his eye.

Other interfaces showed the review status of ontology and implementation blocks, implementation progress and test coverage, and separated pull-request creation, rebasing, approvals and merging into governed steps.

The practical idea is that an enterprise should be able to review a change at the level of meaning rather than only at the level of text.

Kraska provided an example of two developers or agents modifying the same banking application. In traditional enterprise software development, if one dev specifies that a button must be red while another has no opinion about its color and happens to generate blue code, a source-code merge may produce a conflict.

“If we both try to push the code, our code would be in conflict because you say 'red' and I didn’t say anything," Kraska explained. "However, if you look at the semantics, it’s actually compatible because you have an opinion, I didn’t. It should just be merged automatically. There’s no conflict.”

At the semantic layer, G5 could theoretically recognize that only one side actually expressed a requirement and merge accordingly. Two incompatible authentication requirements, by contrast, should trigger a genuine semantic conflict requiring a decision.

That is a more interesting enterprise proposition than simply generating code from English. It attempts to move code review, policy enforcement and change management into an abstracted, yet truthful, canonical representation that product owners, compliance officers and other non-developers can inspect.

From legacy modernization to replacing SaaS with bespoke, custom, AI-coded enterprise applications

G5 Labs' early customers are engaged in a mix of software modernization and replacing costly software-as-a-service (SaaS) applications from third-party vendors with their own applications they build, own and control.

Kraska told VentureBeat that roughly 90% of the organizations it was working with are in financial services, and characterized the engagements as early-stage, but declined to name customers per confidentiality agreements.

VentureBeat saw G5 Labs demonstrate the G5 platform using what the company described as a real, major enterprise customer modernization engagement, with the customer kept anonymous at G5's request.

Launch materials provided to VentureBeat highlight a financial-services modernization project in which the ontology comparison surfaced structural differences that the company says would have been obscured by a conventional code port.

“The typical modernization tool takes the old code and translates it to some new code using AI," Kraska explained. "But you carry over all the issues the old code has. Often, because of timelines and other things, there were decisions in the past, and now these decisions carry over, and you don’t know if they even should be there in the first place.”

Rather than instructing an AI agent to translate an old application directly from one language or framework to another, G5 first tries to recover the system's semantics. The enterprise can then review which old assumptions remain valid, change business requirements or architecture, and generate a new implementation from the revised representation.

“We can, for example, take your old code, uplift it to the semantic representation, and then you can verify a bunch of things and lift it down again," Kraska said.

G5 Labs' website also markets a second route into the platform beyond legacy modernization: replacing SaaS. Its website argues that enterprises can build and own applications around their particular workflows rather than continue paying recurring subscriptions for generalized software, and says doing so could potentially save millions in software costs.

Kraska made a similar argument in his interview with VentureBeat, predicting that the economics of highly customized software will increasingly challenge high-margin SaaS offerings as AI compresses implementation costs.

"fIn the long run, to be honest, not many companies will be willing to pay very high premiums for SaaS software unless they provide huge amounts of value they believe they cannot get otherwise with less cost," Kraska said.

G5 Labs's website notes that its product is "in deployment today" in several heavily regulated industries, and that "millions of lines" of legacy code have been uplifted into semantic ontologies across its work. Those deployment and scale figures are company-reported, and have not been independently verified by VentureBeat.

That distinction matters for procurement. The underlying concept is plausible; the scale and reliability claims remain substantially the company's own.

G5 wants to sit above Claude Code, Codex and other agents — not replace them

G5 Labs is also deliberately not trying to build another frontier coding model or compete head-on with the major coding-agent vendors.

Kraska said the platform sits above the model and coding-harness layer, instructing tools such as Claude Code or Codex and potentially selecting different models for different tasks. That creates an opportunity to use expensive frontier models where necessary and less costly models for simpler work.

G5 is model-agnostic: its interface includes controls for selecting different coding harnesses and underlying models, and Kraska said the platform can also optimize model choice across tasks, using cheaper models where appropriate while directing systems such as Claude Code or Codex to perform the implementation.

The company's website says the platform decomposes an approved plan into verifiable tasks and coordinates multiple agents to execute them in parallel, while grounding the agents' decisions, lessons and intermediate steps into the ontology alongside customer-specific architectural guidance, policies and best practices. If that operates as described, G5 Labs is not merely maintaining a semantic record above coding agents; it also serves as the layer that decides how agent work is divided, constrained and reconciled.

This positioning could be attractive to enterprises that do not want their development control plane tied to a single model vendor. It also means, however, that the G5 platform should be evaluated as an additional layer in the stack rather than as a substitute for the underlying AI coding spend.

The company has built cost checks into that layer. Kraska described cases where an apparently small natural-language request could imply an architectural rewrite; G5 can estimate the prospective cost and require additional confirmation before implementation proceeds.

Governance is similarly central. Kraska argues that as developers supervise larger numbers of software agents, responsibility does not disappear merely because an agent generated the change.

“I don’t think that developers go away," Kraska said. "They will just shift in the skill set. They will become managers of virtual employees—the agents. They will make really high-judgment decisions around architecture, how operations should be done, and other things."

The platform is designed to associate changes with approval processes and policies so organizations can establish who approved a change, which agent or review process was involved, and whether the resulting implementation complied with the relevant requirements.

Kiro and GitHub Spec Kit make the competitive picture more complicated

G5 Labs is entering a market that has moved rapidly toward many of the same ideas, and the underlying premise that implementation code can be derived from a higher-level, technology-independent representation predates generative AI by decades.

The Object Management Group established Model Driven Architecture as the basis of its standards in 2001. MDA starts from a platform-independent model of an application's business functionality and behavior, transforms it into platform-specific models and implementations, and explicitly contemplated regenerating code as underlying technology changed. In other words, "the model is more durable than the generated implementation" is not by itself a new software-engineering idea.

AveriSource, for another example, offers tooling that analyzes legacy applications, extracts business rules and data structures into an intermediate domain model, and uses those models to generate modern Java, C# and microservices-oriented implementations.

Its current Reimagine product similarly positions structured business-function specifications as inputs to AI-native forward engineering while leaving old technical debt behind. That does not make AveriSource equivalent to G5, whose pitch extends into ongoing development, semantic merging, natural-language intent and organizational governance, but it means extracting durable semantics from legacy code and regenerating a modern implementation is not unique to G5.

G5 Labs' claim to novelty is therefore narrower — and potentially more interesting — than "models replace code as the source of truth."

Its bet is that modern language models can make that higher-level representation substantially easier to create and maintain: recovering it from existing software, expressing much of it in natural language, grounding concepts back into implementation, preserving original human intent separately from agent decisions, and using the resulting graph for semantic merges, governance and multi-agent development. Whether G5 Labs can maintain that round trip reliably across a large, continuously changing enterprise codebase is the harder question.

Amazon's Kiro AI coding platform, for example, already offers a structured spec workflow that produces requirements.md, design.md and tasks.md, including requirements expressed in testable EARS notation. It can analyze requirements for contradictions or omissions before implementation, while persistent "steering" files can encode architecture, conventions and other organizational guidance. Kiro's enterprise product now also includes centralized controls over models and MCP servers, prompt logging, activity monitoring and usage analytics.

Kiro is therefore not merely a chat-based code generator with a spec form bolted onto it. It has become a broader agentic development environment spanning IDE, CLI and web workflows.

GitHub's Spec Kit creates an even more direct comparison. The open-source, MIT-licensed project is described as an "intent-driven harness" and supports dozens of coding-agent integrations. Its standard workflow moves from spec to plan to tasks to implementation, while its "living spec" model explicitly allows spec.md to function as the contract from which downstream artifacts are regenerated. It can also run offline and in air-gapped environments.

Importantly, Spec Kit has also evolved since some earlier comparisons of spec-driven tools were written. Its /speckit.converge workflow, introduced in 2026, assesses the current codebase against the spec, plan and tasks, identifies missing, partial, contradictory or unrequested implementation, and adds traceable remediation work. That narrows G5 Labs' ability to distinguish itself simply by saying competing systems do not check code against specifications.

Spec Kit still leaves teams to choose how specifications persist and mutate, however. Its own documentation says a living spec requires teams to regenerate or reconcile downstream artifacts and specifically warns that implementation rationale can be lost unless it is deliberately carried forward.

G5 Labs' novel claim is not "we have specs and they remain important," as competitors already do that. Instead, the G5 platform can maintain a system-wide semantic graph grounded bidirectionally in the implementation, preserve human intent separately from AI-generated implementation choices, detect conflicts at that semantic layer and apply policy and governance across the resulting graph.

Kraska describes G5 as effectively taking the specifications produced by systems such as Kiro or Spec Kit and organizing them into one coherent application-level knowledge graph, then adding grounding, bidirectional compilation, semantic merging and approval workflows.

If that works reliably at enterprise scale, it is a meaningful technical distinction. It is also much harder than generating Markdown specifications.

Tessl is another useful point of comparison. Earlier work on spec-driven development described it as exploring a spec-as-source model. Its current commercial positioning, however, is much more heavily centered on agent skills, plugins, evaluations, shared context and governance. Its enterprise offering includes SAML SSO, policy controls, BYOK, self-hosting and audit capabilities.

Availability is enterprise-led; pricing remains an unanswered question

G5 Labs is not launching with a conventional self-service developer pricing page.

Kraska said the standard deployment is a cloud-hosted environment to which customers receive credentials, although G5 says it can work with banks and other customers that impose stricter infrastructure constraints. For modernization projects, customers either work independently or with G5 to ingest the existing system and construct the initial ontology before changing and regenerating the application.

Its website currently directs prospective customers to "Request Early Access" rather than offering a self-service signup, reinforcing that G5 is presently an enterprise-led deployment rather than a product developers can simply purchase and provision on demand.

The company also says enterprise data remains with the enterprise and that G5 can operate within customers' existing agreements with model vendors — including zero-data-retention arrangements where applicable. "The data stays with the enterprise," Kraska said.

But pricing is not yet public or finalized. "We are still working out our pricing model," Kraska admitted.

That leaves a major variable unresolved for procurement teams, particularly because total cost will encompass not only whatever G5 eventually charges but also the underlying model/API usage, migration effort, ontology creation and ongoing governance overhead.

Competitors provide clearer reference points. Kiro currently ranges from a free tier through paid plans of $20, $40, $100 and $200 per user per month, with additional credits available and separate enterprise administration.

GitHub Spec Kit itself is MIT-licensed open source, although organizations still incur costs for whichever coding agents, models and internal support processes they use with it. Tessl lists a $100-per-month team offering and custom enterprise pricing based on a platform fee and usage credits.

What enterprise buyers should actually test

For CIOs, CTOs and procurement teams, the right question is not whether natural language will play a larger role in programming. That trend is already well underway. The question is whether G5 Labs' system ontology can become a reliable control plane for complex software, rather than another representation that itself drifts out of date.

A serious proof of concept should therefore use a real brownfield application rather than a greenfield demo. Buyers should test whether G5 can recover business intent from an unfamiliar codebase, maintain mappings after engineers make changes outside the platform, distinguish genuine semantic conflicts from harmless implementation differences, enforce an organization's own policies without excessive false positives, and regenerate part of the system into a materially different stack while preserving externally observable behavior. They should also require a complete audit trail showing why each generated change exists and how it maps back to approved intent.

Equally important are operational questions G5 Labs has not yet publicly answered in detail: ontology exportability, failure recovery, exact isolation and deployment options, service-level commitments, supported source-control systems, administrative controls, and how customers avoid making G5 itself a new form of platform lock-in.

That last point is especially important because G5 is asking an enterprise to elevate its ontology into one of the most strategically important artifacts in the software lifecycle. If the ontology really becomes the durable representation of business intent while conventional implementations become increasingly regenerable, portability of that semantic asset may eventually matter as much as portability of the generated source code.

But G5 Labs' thesis has notable backers.

"Past major leaps in software have always come from raising the level of abstraction," investor and fellow former Googler Jeff Dean said, in a statement provided by G5 Labs to VentureBeat. "G5 is a serious, well-engineered attempt at the next one."

Battery Ventures partner and former MongoDB CEO Max Schireson put the argument more aggressively in another statement provided by G5 Labs: "With AI, there will soon be no more reason to write software in Java, C, Python, or Rust. The new language of software development will be English. The missing link is a suite of tools to build a robust software-engineering process around it. G5 is delivering those tools."

The near-term enterprise decision is less sweeping. Organizations do not need to decide whether English will replace Java. They need to decide whether the rapidly growing output of coding agents benefits from a durable semantic and governance layer above source code — and whether G5 Labs can make that layer trustworthy enough to become part of the software-delivery system itself.