Introducing WSO2 Labs: Agentic Engineer

Exploring full life cycle engineering in the world of agents

Agentic coding tools have transformed how software gets built. They've dramatically accelerated code production and lowered the barrier to entry for new developers. But when it comes to enterprise software, developers still find themselves wrestling with the same complexities that have always defined this space: integrations with existing systems, authorization models, security controls, deployment pipelines, and architectural conformance. These concerns blunt much of the productivity gain that agentic tools promise in greenfield scenarios.

The reality is that when building enterprise software, the majority of engineering time isn't spent typing code. It's spent figuring out requirements, designing an architecture that fits within an existing ecosystem, and wiring the new system into a web of services, identity providers, and data stores. To unlock the next level of productivity, agents need to do more than generate code. They need to operate inside an environment that understands and enforces these enterprise concerns automatically.

The enterprise software problem is exactly the space WSO2 has worked in for the better part of two decades. So we kicked off the “Agentic Engineer”, a lab project to explore what an agentic engineering experience for production quality code and systems might look like. We built it on top of OpenChoreo, an open source developer platform built on Kubernetes that we recently donated to the Cloud Native Computing Foundation (CNCF). OpenChoreo already handles API management, identity, deployments, observability, and policy enforcement, so the agents can build on that foundation rather than re-implementing it. What they produce then runs in an environment that already understands enterprise concerns.

This is an early experiment, and we're sharing it in that spirit to learn what works, what doesn't, and where the interesting problems actually sit. It also serves a secondary purpose of validating and informing OpenChoreo’s agent use readiness, as realized in its MCP server and skills+CLI, so it could robustly serve as a cloud native, enterprise-grade backend for any agentic coding platform or tool.

What we set out to explore

The Agentic Engineer is designed around a few core goals, which extend beyond state of the art agentic development experiences as follows:

• Build a system where agents drive each stage of the Software Development Lifecycle (SDLC), with humans in the loop to intervene as needed.
• Bring business owners closer to the development process so they can drive applications from intent, not from tickets.
  Provide a shared surface where business and technical users and their agents can collaborate on the same artifacts, each with a view suited to them.
• Enforce architectural conformance and security requirements automatically on every application the system produces.
• Give agents first-class access to the full catalog of enterprise services so they can discover and integrate with existing systems rather than reinventing them.
• Close the feedback loop so agents can detect runtime issues and remediate them autonomously.
• Stay Git- and GitHub-native so engineers can drop into the code at any stage of the lifecycle without leaving familiar tools.

How the experience flows

The journey starts with a business owner describing the solution they need. A built-in chat agent guides them through requirements elicitation, while a shared workspace gives business analysts, designers, and engineers room to refine the spec and shape the intended experience. Everything is captured as spec files in a Git repository, and those specs become the contract the downstream agents work against (making the whole chain inspectable, reviewable, and editable through the tools engineers already use). The video below walks through it end-to-end.

What you see here is an early preview. The foundations (spec-driven development, specialized agents, customizable skills, an explicit human-in-the-loop boundary) open up a design space we're still mapping.

The agents

The system is driven by a set of specialized agents, each scoped to a stage of the lifecycle, from gathering and shaping requirements, through architecture, code, and deployment, to monitoring the running system. Every agent is given only the tools and skills relevant to its task, which keeps it focused and predictable. They also operate under guardrails enforced by the platform, staying within the policies the organization has set for them.

Because the agents share context across the artifacts they produce, the system stays internally consistent. Update a requirement and the wireframes, specs, and downstream artifacts move with it; you don't have to chase the change through the project by hand.

Skills are the primary customization surface. Organizations encode their own conventions through skills: how requirements are captured, preferred architecture patterns, naming standards, security baselines, the approved service catalog. This is how organizational standards become something the agents actually apply, rather than documents that sit alongside the work.

The system is not tied to a single LLM provider. You can choose the model behind each agent, and mix providers across the lifecycle, matching capability to task and keeping spend under control.

Try it yourself

The project is open source. If you'd like to dig into the implementation, run it against your own services, or contribute, you'll find it here.

Since this is a lab project, feedback shapes where it goes next. We're especially interested in hearing from teams working through similar problems: what felt natural, what got in the way, how skills map to the way your organization actually builds software, and where the agent boundaries should sit for your stack.