The Kubiya Manifesto

Manifesto: Stop Automating, Start Delegating

Prologue: The Evolution of the AI Engineering Role

In the rapidly evolving world of software, the role of the engineer has continually transformed—from backend to full stack, from DevOps to platform engineering. Now, with the emergence of foundation models, agents, and orchestration systems, we are witnessing the rise of the AI Engineer: the architect of systems that marry intelligence with infrastructure.

But this isn’t just a change in title. It’s a redefinition of responsibility. In the era of GenAI, we stand on the edge of the most consequential shift in computing since the advent of the cloud. This moment will define which companies scale their AI investments into production—and which don’t. It will define who leads and who lags. And the determining factor won’t be who prompts better—it will be who delegates better.

Automation, once the prized solution for scaling operations, is now merely a tactic. Delegation is the new strategy. And the AI Engineers who embrace this will become the foundational builders of modern software organizations.

Chapter I: The Problem with an Automation-first approach

AI Engineering today is caught in a paradox: we spend massive amounts of engineering time trying to automate tasks that should no longer be ours to own. Building and maintaining brittle scripts, writing infrastructure glue code, stitching notebooks to APIs, and patching orchestration logic by hand—these aren’t signs of progress. They’re indicators of entropy.

This is the Time-to-Automate Paradox. The more we try to automate, the more we entrench ourselves in custom systems that decay under scale, policy, and change. Valuable engineering time is consumed maintaining orchestration layers that should be dynamic and delegated.

And when it comes to deploying models, fine-tuning pipelines, accessing infra, running evals, or managing LLMOps—most teams still rely on manual reviews, YAML sprawl, or scattered permission layers.

This isn’t sustainable. And it isn’t strategic.

Chapter II: The Rise of Delegation in AI Systems

Delegation is not outsourcing. It’s intelligent offloading.

Modern AI systems need infrastructure that can interpret intent, govern execution, and adapt in real-time to policy, state, and business context. That’s what Kubiya enables.

With Kubiya, workflows aren’t just hardcoded—they’re declared. Agents don’t just run—they listen, enforce, audit, and contain.

By reducing “time to automation” to a single declarative sentence, AI Engineers can offload operational toil like:

• Managing fine-tuned model deployments
• Granting short-term access to secrets or GPUs
• Running RAG pipelines in isolated containers
• Enforcing cost or compliance constraints in real time
• Self-healing eval or CI/CD environments

And they can do it without needing to babysit infrastructure or write one more brittle integration.

Kubiya enables you to build systems, not scripts.

Chapter III: Delegation Is the New Standard

The promise of AI Engineering is not just faster models or smarter APIs. It’s in building reliable, secure, scalable systems. Delegation isn’t a feature—it’s an architectural principle.

With Kubiya, AI Engineers reclaim their time to:

• Innovate across LLMOps and RAG stacks
• Scale experimentation with safety rails
• Embed governance without friction
• Align daily execution with strategic impact

No engineer finds joy in debugging another provisioning script or explaining for the fifth time why a notebook shouldn’t have production access. But every engineer thrives when given tools that remove toil and amplify agency.

Delegation delivers that shift—from reactive builders to proactive architects.

Chapter IV: The Urgency to Adapt

Ignore this shift, and you risk becoming the next Blockbuster.

The AI-native enterprise won’t be built by hand-wired automations or monolithic ML platforms. It will be assembled by modular, declarative, agentic systems that can reason, respond, and comply—automatically.

Organizations that embrace delegation-first design will move faster, safer, and smarter. Those that cling to legacy ops mentalities will slow themselves under the weight of scripts and silos.

Delegation is the unlock. It’s what makes AI Engineering scalable.

Chapter V: A Future Built on Intent, Not Toil

Imagine a future where every pipeline, permission, deployment, and evaluation can be triggered by intent—but executed with security, observability, and repeatability.

Where environments spin up for private LLM experiments without ticket queues. Where agents enforce policy dynamically. Where your time is spent on designing systems—not maintaining them.

This is not a dream. This is already happening.

Kubiya isn’t building tools. We’re building the control plane for delegated AI infrastructure.

Conclusion: Delegate What Doesn’t Differentiate

The true job of the AI Engineer is not to write automation—it’s to design systems that scale intelligence.

That means offloading the heavy lifting. That means trusting infrastructure with orchestration. That means building delegation into the foundation of your AI stack.

Don’t automate what you can delegate. Don’t script what should be declarative. Don’t do what can be offloaded to intelligent, governed infrastructure.

That’s what winning looks like.

Let’s build the future of AI systems the right way—together.

Amit Eyal Govrin

CEO & Co-Founder, Kubiya.ai