Why we invested in Graftcode

Software doesn’t break because developers can’t code. It breaks because the systems they build can’t talk to each other and the integration code required to make them communicate has become the single largest drain on engineering time and budget.

According to Forrester, up to 70% of software development work today is integration code – wiring frontends to backends, building REST controllers, managing serialization, maintaining API versioning. None of this is business logic. None of it delivers value to end users. It’s pure overhead. And the cost adds up: McKinsey estimates that technical debt consumes around 40% of IT assets and adds 10-20% to every project’s budget. Deloitte puts the annual cost of technical debt in the United States alone at approximately $1.5 trillion.

This isn’t a niche problem. It affects virtually every software project on the planet. That’s why Hard2beat led an investment round in Graftcode, a devtools startup that doesn’t manage integration complexity but eliminates it entirely.

The Problem: Integration Code Is Eating Software Development

Every developer knows the drill. You want to call a Python module from a Java service. Or connect a React frontend to a .NET backend. Or migrate one microservice without breaking ten others. In each case, the actual business logic takes minutes. The integration work of building APIs, writing client libraries, setting up middleware, handling serialization and testing takes hours or days, and you maintain it forever.

The industry went all-in on microservices, expecting agility and scalability. What many teams got instead was an explosion of API endpoints, serialization layers, and operational overhead. A growing number of enterprises are pulling back from microservices toward simpler, more modular architectures. But there has been no clean way to make that transition – teams are stuck choosing between architectural complexity and painful rewrites.

As if this weren’t enough, the rise of AI is making the problem worse, not better. AI coding assistants are remarkably good at generating business logic. But they struggle with integration: large codebases bloated with integration code exceed context windows, AI agents can’t orchestrate services entangled in middleware, and generated integration code hallucinates incompatibilities. Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027. The reasons range from escalating costs to unclear ROI, but a recurring theme is that existing IT architectures built on layers of integration code simply aren’t ready for autonomous AI workflows

At Hard2beat, we look for deep-tech companies that eliminate entire categories of problems rather than layering on yet another management tool. Graftcode does exactly that.

The Solution: Removing APIs and Integration Code

Graftcode takes a fundamentally different approach to software integration. Instead of providing a better way to manage APIs, middleware, and client libraries, it removes the need for them altogether.

The core technology is called runtime bridging. Using a proprietary binary communication protocol (Hypertube), Graftcode enables applications written in different programming languages to call each other’s methods directly, whether they run in the same process or on a remote server. The developer experience is the same in both cases. No REST endpoints. No gRPC stubs. No middleware. No client code.

In practice, it works in three steps:

The developer runs a lightweight Graftcode Gateway alongside their service. It automatically detects and exposes all public methods.
A single command in the developer’s existing package manager (npm, pip, NuGet, Maven) generates a strongly-typed connector called a “graft.”
The developer imports the graft like any other package. Methods are strongly typed, so they work with IDE autocompletion and compile-time validation out of the box. Whether the target runs locally or on a remote server, the code looks exactly the same.

What used to take days of integration work becomes a one-command operation. The graft auto-updates whenever the target service’s API evolves. There is no integration code to maintain, no serialization to debug, no versioning headaches.

The performance results back this up: service interactions run up to 70% faster than conventional web services, with one-eighth the CPU consumption compared to gRPC and REST for equivalent workloads. The platform currently supports 14 programming languages across all major cloud providers.

As Przemysław Ładyński, co-founder and CEO of Graftcode, put it: “For two decades, the software industry kept optimising how systems connect rather than questioning whether that complexity should exist at all. We built Graftcode to remove the integration layer entirely, not improve it.“

Why This Matters for AI Development

AI coding tools excel at generating business logic but consistently fail at system integration. They can’t reliably produce correct API bindings, manage middleware configurations, or navigate the accumulated technical debt of integration layers. By removing this layer entirely, Graftcode lets AI agents focus on what they’re good at: writing and orchestrating business logic across clean, strongly-typed interfaces.

There’s a second angle. As more services need to be consumable by AI agents via protocols like MCP (Model Context Protocol), companies face the prospect of building yet another set of integrations. Graftcode sidesteps this: any service exposed through a Graftcode Gateway is automatically available via MCP, with no additional work. Existing backends become AI-ready out of the box.

Why Now: Microservices Fatigue, AI, and Legacy Systems

Three tailwinds are converging to make this the right moment for Graftcode.

The microservices backlash. After a decade of splitting everything into small services, the industry is course-correcting. Teams want modularity without the operational tax. Graftcode enables “modular monolith” architectures where code is logically separated but can run as a single application or as distributed services, switchable through configuration alone.

The AI development bottleneck. Organizations racing to build AI-native applications are discovering that their integration architectures are the primary blocker. Systems built on layers of integration code are hostile to AI agents that need clean, predictable interfaces. Graftcode removes this obstacle.

The legacy modernization imperative. Enterprises globally have trillions invested in legacy systems that are expensive to replace but critical to operations. Graftcode lets organizations wrap legacy components in modern interfaces without risky rewrite projects.

Like Docker and HashiCorp’s Terraform, Graftcode is built on the conviction that infrastructure technology can only become a true standard if it is free. The core platform is and will remain free for all developers, with premium and enterprise tiers for larger projects and privacy-sensitive organizations.