RolePilot

AI casting copilot that understands requirements, matches approved materials, prepares applications, and stops for human approval before anything is submitted.

Comment

Inspiration

Casting platforms solve an important problem, but applying through them is still surprisingly repetitive. Independent actors repeatedly enter the same profile information, search for the same approved photos and videos, and translate slightly different casting briefs into the same manual checklist.

The frustrating part is not only the typing. A wrong photo, a missed self-tape requirement, or an application treated as complete when something is still missing can cost a real opportunity.

I wanted to rebuild this workflow around a better division of responsibility: software should understand the brief, organize repetitive preparation work, make uncertainty visible, and return control to the human before any consequential external action.

What it does

RolePilot turns a casting opportunity into a controlled application workflow.

It:

  • converts a casting brief into explicit requirements
  • checks those requirements against an approved material library
  • shows whether the application is READY, NEEDS RECORDING, or needs REVIEW
  • identifies missing requirements instead of pretending the application is complete
  • creates a persisted application run
  • records an audit trail of the preparation process
  • stops at a visible human approval gate before any external submission

The hackathon demo intentionally does not submit a real casting application.

The goal is safe delegation: automate repetitive preparation, preserve truthful application state, and keep final authority with the user.

How I built it

Xano is the backend source of truth for the hackathon build.

It stores:

  • casting opportunities
  • approved asset metadata
  • application runs
  • audit events
  • approval state

The RolePilot frontend communicates with Xano through a dedicated REST API group with endpoints for:

  • loading opportunities
  • analyzing readiness
  • creating application runs
  • recording human approval decisions

The frontend is also deployed using Xano Static Hosting, so the public demo is connected directly to the live Xano backend.

For reliability and inspectability, the readiness logic in this hackathon version is intentionally deterministic for the three synthetic demo opportunities. This makes the state transitions easy to verify and avoids presenting runtime behavior as more autonomous than it actually is.

AI was used heavily to accelerate the build itself. Xano Agent with Xano's provided Google Gemini generated the first backend implementation from a detailed product specification. ChatGPT was used for product architecture, workflow design, frontend implementation, integration QA, deployment support, and submission packaging.

The frontend is intentionally lightweight because the important part is not another dashboard. The important part is making incomplete applications truthful and making the boundary between preparation and external action impossible to miss.

Challenges I ran into

The hardest problem was defining a truthful state model.

A system can find three matching assets out of five and still produce something that looks convincing. In a casting workflow, that is dangerous.

RolePilot therefore distinguishes between READY, NEEDS RECORDING, and REVIEW instead of turning every partial match into a positive result.

The second challenge was making human-in-the-loop control part of the actual product rather than a disclaimer.

Application runs, audit events, missing requirements, and approval state are first-class parts of the workflow. The system does useful preparation work, but the consequential external action remains deliberately outside the automated flow.

Accomplishments I'm proud of

  • The workflow is understandable without technical documentation
  • Missing requirements remain visible instead of being silently guessed
  • Xano powers the live opportunity data, run state, audit events, and approval state
  • The public frontend is deployed through Xano Static Hosting
  • The system demonstrates both useful automation and deliberate non-automation
  • Competition-safe synthetic data keeps private casting materials out of the demo
  • The same interface demonstrates READY, NEEDS RECORDING, and REVIEW states
  • The complete preparation flow is persisted and auditable

What I learned

Agentic software becomes more useful when it knows when not to act.

For consequential workflows, full autonomy is not always the best product.

A better system can understand context, prepare repetitive work, preserve state, expose uncertainty, and return control to the human exactly where judgment matters.

I also learned how quickly a working backend can be assembled when Xano's data model, APIs, Agent workflow, and hosting are combined with AI-assisted product development.

What's next

  • support more casting and application schemas
  • add richer multimodal matching of approved photos and videos
  • add deadline tracking and opportunity deduplication
  • connect readiness analysis to visible browser-based form preparation
  • add reusable application history for actors and talent teams
  • support configurable approval policies for different application types
  • replace deterministic demo analysis with a production-grade structured extraction and validation pipeline

Xano challenge build story

Software replaced: traditional casting application portals and their repetitive application workflow.

Why this workflow: actors repeatedly translate inconsistent casting briefs into the same profile fields, media selections, recording requirements, and manual checks. The work is repetitive, but the final action is consequential, which makes it a strong use case for human-in-the-loop automation.

How Xano is used: Xano provides the live database, REST API layer, persisted application runs, audit events, approval state, and Static Hosting for the public frontend.

AI tools used: Xano Agent with Xano's provided Google Gemini for the first backend implementation, plus ChatGPT for product architecture, workflow design, frontend implementation, integration QA, deployment support, and submission packaging.

Build time: approximately 1.5 focused hours from Xano setup to a deployed and tested end-to-end hackathon demo.

What AI + Xano accelerated: without AI-assisted development and Xano, creating the database model, connected API flows, readiness logic, persisted audit state, approval workflow, frontend integration, testing, and production deployment would have taken significantly longer to implement and debug manually.

Runtime AI note: the readiness logic in this hackathon version is intentionally deterministic for the synthetic demo opportunities. AI accelerated the design and implementation of the product, while the demo runtime remains reliable, transparent, and easy for judges to inspect.

Built With

Share this project:

Updates

Submission history