Connectors are the backbone of identity security. You can’t protect what you can’t see, so getting a complete view of identity and access across your environment is a critical first security step. But pulling all of your identity and access data into a centralized platform is anything but straightforward: it’s one of the biggest challenges for identity teams and vendors.
At ConductorOne, we recognized from the start that our platform had to solve this data challenge. So we built an open source connector ecosystem called Baton that established a universal governance standard with which to ingest to and translate identity data from any source. The Baton SDK allows our team and other developers to code robust connectors in Go to any system, including hard-to-integrate legacy and homegrown systems. The SDK is a powerful tool, but it comes with a catch: you have to write code, which takes both knowledge and time.
The solution was a new set of generic Baton connectors designed to be built using a single YAML configuration file instead of code. That shift made connector development faster and accessible to more people, but it also opened the door to a bigger leap: using AI to generate those configuration files automatically.
How AI-generated connectors work
We created a framework where you can build a connector with a single YAML configuration file. Because the schema is well-defined and many APIs follow common patterns, this made it possible to take the next step: building an AI agent that can generate those configurations automatically.
Here’s what that looks like:
- Schema and examples: We provide the agent with our schema and examples of working configurations.
- API analyzation: Given the schema and rules, the agent can read the API documentation for a service and extrapolate how a configuration file should be structured.
- Configuration and validation: The agent then configures the YAML file and checks that the file is valid against our schema and can produce a working connector.
- Human-in-the-loop: Engineers review and test the connector to make sure it actually works before shipping.
That combination of a pre-built generic connector and an AI agent prompted to use our configuration schema, and validate the results is what takes connector generation from multiple days of manual coding to just a few hours. With this process, our API analyzer agent has already built more than 30 production-ready connectors.
From days to hours: why it matters
Manually coding a new connector used to take days of engineering effort. With AI-generated configurations, that timeline shrinks to hours. The only prerequisite is solid API documentation, and the rest is handled by AI.
The impact is huge:
- Faster coverage: Connect more applications without waiting on developer time.
- Greater accessibility: Teams without Go expertise can now build connectors.
- Scalable integration: Even the long tail of apps becomes feasible to support.
By combining structured schemas, AI, and human validation, ConductorOne is setting a new standard for speed and scale.
AI-native and continuously refining
AI-generated connectors mark a big step forward, but they’re only the beginning. Because ConductorOne is AI-native, this capability will continue to evolve as we refine our framework and models.
We’ve already proven the approach by building more than 30 connectors with our API analyzer. Each iteration improves accuracy, validation, and the overall developer experience. Over time, the process will become even faster and more reliable while still keeping human-in-the-loop guardrails in place to ensure quality.
As identity ecosystems grow more complex, our commitment is to keep pushing the boundaries of what AI can do for integration. By refining and scaling this approach, we’re making it possible for teams to connect more systems, more quickly, with less friction than before.
Book a demo to learn more.
