Reports to: Senior Director, AI Products & Platforms

Level: Senior Manager equivalent, individual contributor

Location: United States. Full East Coast business-day overlap required; East Coast base preferred, not required.

TKO has deployed Glean to Wave 1 across WWE, UFC, IMG, PBR, On Location and Corporate. The platform is live. What does not yet exist is a verified core of agents, skills and Glean projects that encode how TKO actually works — built once, trusted, and reused across business units rather than rebuilt locally six times.

This role builds that core. It is a hands-on build seat, and the work starts upstream of the build: going into a team's actual workflow, understanding how the work really gets done, and identifying which part of it is common enough across TKO to be worth building as a verified, supported capability. Then building it — instruction sets, sources, actions, evaluation — and shipping it as the canonical version other teams adopt and extend.

The distinction that matters: this role does not exist to service agent requests. It exists to find the workflows underneath those requests, decide which ones generalize, and produce the small number of verified artifacts that let the rest of the organization build on top of them.

This is a builder, not a coordinator. That distinction is the single most important filter for this hire.

Plenty of strong candidates can run a program — track a plan, chase owners, produce a status deck. That is not what this seat needs. The person here has to open Glean, write the prompt and instruction set, wire up the sources and actions, test against real edge cases, watch where it fails, fix it, and ship a working agent. Then do it again and teach someone else to do it.

Concretely, builder means:

• You have personally built and shipped AI agents or assistants that other people actually used — not scoped them for someone else to build, not overseen a vendor building them.
• You can write and iterate a system prompt or instruction set well enough to get a reliable answer out of an unreliable model.
• You can explain why a given agent is failing, and distinguish between the causes: retrieval, permissions, instructions, source coverage, or intent scope.
• You can design and run your own evaluation — build a test set of real user intents, define what a good answer looks like, measure fallback and error rates, and use that to decide whether something is fit to launch.
• You are fluent enough in the platform to tell the difference between a genuine product gap that belongs on the vendor's roadmap and something you could solve yourself in an afternoon.
• You can look at twenty agent requests from six business units and see the three underlying capabilities worth building.

This is not a central agent-building service. Business units and individual teams are expected to build their own agents for their own local workflows, and this role exists to make that possible — not to do it for them.

Specifically, this seat does not:

• Take agent requests and work them in order of arrival. Incoming demand is input to a prioritization judgment, not a queue commitment.
• Build one-off agents for single teams where the underlying workflow does not generalize and the team could build it themselves. The answer in that case is a pattern, a template, and a working session.
• Act as the platform help desk. Individual user support, access issues and how-do-I questions route to IT Service Delivery and the enablement team.

The correct read: a small number of verified, cross-functional builds that many teams depend on, plus the library and training that let teams build the rest without this person in the loop.

The output of this section is a deliberately small set of agents, skills and Glean projects that are verified, documented, supported and reused — not a high volume of individual builds.

• Personally build and ship the verified cross-functional artifacts: agents, skills and Glean projects that encode a workflow shared across business units or corporate functions. Including the politically visible and technically awkward ones. This is hands-on delivery, not oversight.
• Own those artifacts as products, not deliverables. Each one has a named absorbing owner in the receiving teams, a standing feedback cadence, a stated scope, and a versioning and update path as workflows change.
• Establish what verified means at TKO and hold the line on it: tested against real intents, documented scope and limits, known owner, monitored, and safe for another team to build on top of without re-litigating it.
• Define and hold the quality bar before an agent goes live: top user intents covered, out-of-scope handling, human handoff path, success measures, and daily monitoring through the first two weeks.
• Design and run the evaluation for every agent — real-intent test set, defined success criteria, measured fallback and error rates — and use it as the launch gate.
• Run post-launch review on every agent. Low-adoption agents get a documented hypothesis and a decision: iterate, retire, or re-promote. Nothing sits live and unused.
• Diagnose and fix failures at the platform level. When the cause is a genuine product gap, escalate it with a reproducible case rather than a complaint.

Deciding what belongs in the verified core is the hardest judgment in this role, and it cannot be made from a request form. It requires understanding the underlying work.

• Go into the actual workflows. Sit with teams across WWE, UFC, IMG, PBR, On Location and the corporate functions and understand how the work genuinely gets done — the steps, the systems, the handoffs, the workarounds people have invented — not the summarized version in a request.
• Separate the workflow from the ask. Teams describe solutions; this role identifies the underlying process and judges whether it is genuinely local or a TKO-wide pattern wearing local vocabulary.
• Look at twenty requests from six business units and name the three underlying capabilities worth building. Decline the other seventeen with a reason and a path — a template, a pattern, or a working session.
• Bring a recommendation on where to concentrate: which capability areas justify a verified central build because they generalize, which justify a single-business build because value is genuinely concentrated there, and which the team should build itself.
• Maintain a live picture of workflow coverage across TKO: which processes have a verified capability behind them, which are being solved locally in incompatible ways, and where a proven pattern from one business should be promoted into the core.
• Be trusted by every business unit while still saying no, and be able to explain the prioritization logic in terms each business recognizes.

The measure of this section is that teams build their own agents competently, without this person in the loop.

• Build and maintain the pattern library: templates, worked examples, reference instruction sets, and annotated versions of what works and why.
• Publish the logic for what belongs in the verified core versus what a team should build itself, so the boundary is understood rather than negotiated case by case.
• Run agent-building working sessions where teams leave with a shipped or near-shipped agent of their own. The intent is capability transfer, not intake.
• Make the verified core genuinely extensible. Teams should be able to build on top of a verified skill or project rather than starting over and know what they can safely change.
• Solve discovery. As the internal agent count grows, users cannot tell which agent is the right one, or which are verified versus experimental. Own how agents are surfaced, named, described and ranked so the catalogue stays usable and trust is legible.
• Make best practice travel. When one business unit solves something well, package it into the library — and promote it into the verified core when it generalizes.

• Design and deliver hands-on agent-building training for business unit users and champions. Lead the sessions personally.
• Build the curriculum from real builds, not generic platform material — the exercises should be the actual workflows teams brought forward.
• Teach teams to build for themselves, including when to extend a verified skill or project rather than start from scratch.
• Hand the delivered framework and materials to the change and enablement team so they can run repeat cohorts without you.
• Produce the day-one and role-based starting-point content for Wave 2 cohorts: starter agents, worked examples, and the "what do I use this for" material for each role.
• Judge readiness honestly. Say when a team is not ready to build on its own, and what must change first.

Deliberately narrow. Enough structure that demand is visible and decisions are traceable — not a request-management function.

• Maintain one current view of the verified core and what is coming: agents, skills and Glean projects, including notable BU-built one’s worth promoting.
• Provide a known path for teams to surface workflow demand, understood as input to prioritization rather than a service commitment. Use the enterprise AI scoring framework already in place rather than standing up a parallel one.
• Keep decisions traceable: what was built, what was declined and why, and what was pushed back to the team with a pattern.

Deliberately light. This role is judged on what it ships, not on what it reports.

• Issue a short weekly written update: what shipped, what is blocked, what decision is needed. Unprompted.
• Maintain a live action log for build commitments with owners and dates.
• Come to reviews and one-to-ones with a recommendation and the tradeoffs, not the open question.
• Surface risk early enough to plan around it.

• Build and ship at least three verified artifacts end to end — agents, skills or Glean projects — including two from the existing priority backlog.
• Work directly with at least fo