Twice this week, Polish technology projects made global headlines. We recently wrote about Bielik — the Polish AI model Jensen Huang featured on the NVIDIA stage. Now another Warsaw startup has raised European funding for technology that could change how developers connect software systems.
For the last two decades, the industry focused on connecting systems more efficiently. Graftcode asked a different question: what if that integration layer did not have to exist at all?
On 14 April 2026, Graftcode announced a €2.1 million round led by Hard2beat, with DigitalOcean Ventures, the HEARTFELT_ fund, and private investors participating. Total funding for the company is now €6.5 million. A public beta of the platform launched at the same time.
The problem that eats 30–40% of the IT budget
Developers can spend up to 70% of their time writing code that is not the product. It is plumbing — APIs, wrappers, serialization, clients — code that exists only so one system can talk to another.
Every CTO knows it. Most accept it as the cost of building anything complex.
The numbers confirm the scale: Graftcode’s team estimates 30–40% of engineering time goes to so-called API plumbing — DTOs, queues, versioning, and client libraries. Forrester goes as far as 70% lost on integration glue. McKinsey estimates technical debt from complex integrations consumes about 40% of IT assets and raises project costs by 10–20%. Deloitte puts the annual cost of that problem in the US alone at $1.5 trillion.
For a business owner that sounds abstract. The effect is concrete: you order a new feature, engineers quote three months — two of them are integration with existing systems. You pay for glue, not for product.
What Graftcode does — three steps instead of weeks
Standard integration tools try to simplify the glue. Graftcode goes further: why glue at all?
The company built runtime bridging. The idea is simple: two applications written in different programming languages can talk to each other directly — without APIs, middleware, or a client SDK. In practice, three steps:
Step 1: Run the gateway with your backend
gg.exe --runtime <your_runtime> --modules <your_backend_library>
Graftcode’s lightweight gateway automatically exposes all public classes and methods from your backend.
Step 2: Generate the client with one command
npm install @graftcode/my-service
One line in your package manager (npm, pip, Maven, NuGet, …) — and you get a strongly typed client that updates automatically when the service API changes.
Step 3: Call a method as if it were local
You import service classes like a local library and call methods through a strongly typed interface. Zero integration boilerplate.
Przemysław Ładyński, co-founder and CEO of Graftcode:
"For two decades, software optimised how systems connect instead of asking whether that complexity should exist at all. We built Graftcode to remove the integration layer entirely — not to polish it."
A concrete example from the docs: Python becomes an AI tool in minutes
This is not a made-up scenario — it is the official tutorial in Graftcode’s documentation on GitHub.
You start with a plain Python class. No decorators, no frameworks:
class EnergyPriceCalculator:
def get_price():
return random.randint(100, 104)
def calculate_bill(kwh_used):
price_per_kwh = random.randint(100, 104)
return kwh_used * price_per_kwh
You add one Dockerfile with Graftcode Gateway. Build the container. That is it — your Python class is now available over MCP (Model Context Protocol). No MCP server code. No tool definitions. No JSON schemas.
Claude or Cursor can now ask:
"What is the current energy price?"
The agent automatically discovers EnergyPriceCalculator.get_price() and calls it. You can also type:
"Calculate the energy bill for 250 kWh"
The agent calls calculate_bill(250) and returns the result. When you add a new method to the class, the agent sees it immediately — no config update.
Without Graftcode, the same flow would require:
- an MCP server implementation with tool definitions for every operation
- manual mapping of each tool to business logic
- JSON schemas for inputs and outputs
- updating those definitions whenever the backend changes
With Graftcode: one Dockerfile, two terminal commands.
The architecture tutorial is equally striking: you can start with a monolith (two modules in one container), then pull one module into a separate microservice by changing one environment variable:
# Monolith — everything in-process
host=inMemory
# Microservice — module in its own container
host=price_calculator:9092
Same code. Same Docker image. Different configuration. You can switch either way without a single line of application code changing.
Under the hood runs Graftcode’s own Hypertube protocol — binary messages with native runtime integration. That is where the numbers come from: about 70% faster and 1/8 the CPU compared with REST or gRPC.
The platform supports 20 programming languages and 10 package managers (npm, pip, Maven, NuGet, Go Modules, and more).
Who already uses Graftcode
Beta does not mean “just starting”. On graftcode.com you will find companies that already ship the technology — including several global names:
- IBM — enterprise integration in polyglot environments
- Siemens — industrial and IoT system integration
- TotalEnergies — data pipelines in cloud environments
- First Premier Bank — fintech where every millisecond and every type must be exact
- TRUMPF — advanced manufacturing and control systems
That companies of this calibre test the technology before a full launch is a strong signal. Adam Bartkiewicz of DigitalOcean Ventures confirms:
"Companies reached out to us even before the beta launched — that kind of developer pull is the strongest signal we look for."
Technical numbers — what developers actually get
Beyond convenience, there are figures. Graftcode claims its approach delivers:
| Metric | Result |
|---|---|
| Speed vs. classic web services | ~70% faster |
| CPU vs. gRPC/REST | 1/8 (12.5%) |
| Supported languages | 20 |
| Package managers | 10 (npm, pip, Maven, NuGet, Go Modules, …) |
| Cloud platforms | AWS, Azure, GCP, Kubernetes, Docker |
Cutting CPU to one-eighth of a gRPC baseline is not just performance — it is direct savings on cloud bills. With heavy inter-service traffic, the gap can reach tens of percent of infrastructure cost.
The platform also supports MCP (Model Context Protocol) natively — the standard that bridges AI tools and external systems. Graftcode can expose almost any service as an MCP endpoint in seconds, which makes it a natural fit for AI agents.
Why this matters now — agentic AI
Rising demand for agentic AI is a direct catalyst for the problem Graftcode addresses.
AI agents — systems that execute complex tasks autonomously — must talk to dozens of different services in real time. Every REST or gRPC hop is a potential failure point, latency, and tokens burned generating integration glue.
Gartner predicts that more than 40% of agentic AI projects will be abandoned by 2027 — partly because architectures built on brittle integration cannot keep up with agent requirements.
Graftcode creates native, direct connections. Systems become “AI-ready” without extra integration projects.
Maciej Zawadzinski, partner at Hard2beat:
"With more than 20 million developers worldwide, the need for simpler system connectivity only grows. Graftcode introduces a fundamentally new approach that could change how modern software is built and scaled."
Who is behind the company
Graftcode was founded by brothers Przemysław and Łukasz Ładyński in Warsaw. For more than 20 years they built enterprise integrations for Siemens, Intel, Bosch, and TotalEnergies. For two decades they lived the problem from the inside — they knew exactly where time and money disappeared.
At some point, instead of building a better pipe, they decided the pipe should not be there at all.
This is not a weekend project. They have been building the technology since 2013, investing more than 20 million PLN in R&D. That is part of why the numbers hold up: about 70% faster and 1/8 the CPU versus REST or gRPC.
The business model mirrors Docker and HashiCorp: the core platform is free for all developers. The ambition is similar — become a global integration standard the way Docker became the standard for containers.
What you can do today
If you run a company that depends on several software systems:
- Measure integration cost — ask your team what share of time goes to connecting systems. If it is more than 30%, you have a problem to solve.
- Try the Graftcode beta — the platform is free for developers. Details on graftcode.com.
- Before you commission another integration — ask whether the solution requires long-lived middleware. If yes, add multi-year maintenance to the price.
- When you build AI systems — every agent you plan will need connections to existing systems. It pays to design for runtime bridging from day one.
What you can gain
Graftcode’s headline numbers are clear: ~70% faster connections and 1/8 the CPU compared with REST and gRPC.
The real upside is elsewhere. If your team spends two months on integration instead of one, you save a month of full-team cost. For a four-person engineering team in Central Europe, that is often on the order of €5,000–8,000 per project (depending on rates).
Graftcode targets 200,000 developers by the end of 2026. With IBM, Siemens, and TotalEnergies already in the loop, that scale can move the developer-tools market. And Poland is again a step ahead in the headlines: the second domestic tech story this week to break internationally.