How Tyilt Streamlined Document Generation with Swfte

Hello! It's been a week since our last case study on Fundxyz's Investment OperationsQuick ViewFundxyz's Investment Operations.

Today, I'm excited to share how Tyilt, a fast-growing eGaming company, revolutionized their internal document generation and review processes using Swfte's AI agent platform.

This transformation began when Tyilt's CTO identified that their documentation processes were creating a significant bottleneck for their development and compliance teams. Let's explore their journey.

The Documentation Challenge

Tyilt operates in the highly regulated eGaming industry, where comprehensive documentation is not just good practice—it's a legal requirement across the multiple jurisdictions they serve.

Before implementing Swfte, Tyilt faced several critical challenges:

Volume of Documents

The sheer number of documents required was overwhelming:

• Game Design Documents (GDDs) for each new game title
• Technical Specifications detailing implementation requirements
• Compliance Documentation for each regulatory jurisdiction
• Test Reports for quality assurance and certification
• User Guides for both internal teams and third-party partners

Each month, the company was generating over 500 new documents and revising another 1,200 existing ones.

Manual Process Bottlenecks

The documentation process was highly manual and error-prone:

graph TD
    A[Subject Matter Expert Creates Draft] --> B[Technical Writer Formats]
    B --> C[Legal Team Reviews]
    C --> D[Compliance Team Approves]
    D --> E[Revision Control Updates]
    E --> F[Distribution to Stakeholders]

This workflow took an average of 12 days per document, with some compliance-critical documents taking up to 30 days to complete.

Inconsistent Quality

Documents varied widely in quality and completeness depending on:

• Which team member drafted the document
• Current workload pressures
• Familiarity with template requirements
• Time available for thorough review

These inconsistencies created compliance risks and occasionally delayed product launches.

The Swfte Solution

After evaluating several automation options, Tyilt chose Swfte for its ability to create customized AI agents that could be trained on their specific documentation requirements and integrated into their existing workflow.

Document Generation Agents

Tyilt built three specialized agents to handle different document types:

const gameDocAgent = {
  name: 'Game Documentation Specialist',
  purpose: 'Generate and maintain standardized game design documents',
  capabilities: [
    'extract_game_parameters',
    'structure_design_documentation',
    'ensure_terminology_consistency',
    'track_version_changes',
  ],
  integrations: ['jira', 'confluence', 'unity_asset_server'],
  knowledge_base: [
    'tyilt_game_mechanics_library',
    'regulatory_requirements_by_region',
    'previous_game_documentation',
  ],
};

What made these agents particularly powerful was how they were trained. Tyilt provided:

1. Historical examples of high-quality documents
2. Regulatory guidelines from different jurisdictions
3. Previous compliance feedback and corrections
4. Style guides and terminology standards

The agents weren't just templating systems—they were intelligent assistants that understood content requirements and compliance needs.

Workflow Automation

Beyond just generating documents, Tyilt created integrated workflows that connected these agents to their existing systems:

const documentationWorkflow = createWorkflow({
  name: 'Game Documentation Pipeline',
  description:
    'End-to-end process for creating and approving game documentation',
  triggers: {
    manual: true,
    gameDevMilestone: ['concept_approved', 'prototype_complete', 'alpha_build'],
    scheduledUpdates: '0 0 1 * *', // Monthly reviews
  },
  steps: [
    {
      name: 'Initial Document Generation',
      agent: 'gameDocAgent',
      action: 'generate_initial_draft',
      inputs: {
        game_id: '{{trigger.game_id}}',
        milestone: '{{trigger.milestone}}',
        project_data: '{{jira.getProjectData(trigger.game_id)}}',
      },
      outputs: ['draft_document'],
    },
    {
      name: 'SME Review',
      type: 'human_task',
      assignee: '{{jira.getProjectLead(trigger.game_id)}}',
      inputs: ['draft_document'],
      outputs: ['sme_reviewed_document', 'sme_feedback'],
    },
    {
      name: 'Compliance Check',
      agent: 'complianceDocAgent',
      action: 'verify_regulatory_compliance',
      inputs: {
        document: '{{steps.sme_review.outputs.sme_reviewed_document}}',
        jurisdictions: '{{game_metadata.target_jurisdictions}}',
        previous_feedback: '{{steps.sme_review.outputs.sme_feedback}}',
      },
      outputs: ['compliance_verified_document', 'compliance_issues'],
    },
    // Additional steps omitted for brevity
  ],
});

This workflow connected their documentation process to their existing project management system, ensuring that documents were automatically generated at the right project milestones.

Integration with Existing Systems

A key factor in Tyilt's success was how seamlessly they integrated Swfte with their existing tools:

• Jira: For project tracking and workflow triggers
• Confluence: As the document repository
• Unity: To extract game parameters directly from the development environment
• Slack: For notifications and approval requests
• Regulatory Databases: For up-to-date compliance requirements

Swfte's flexible API made these integrations straightforward, allowing the agents to pull information from and push updates to the systems their teams were already using.

Implementation Journey

Tyilt took a methodical approach to implementing their documentation automation:

Phase 1: Agent Development (2 months)

The first phase focused on building and training the document generation agents:

1. Knowledge Base Construction: Importing existing documentation, regulatory requirements, and style guides
2. Agent Training: Teaching the agents to understand document structure and content requirements
3. Output Validation: Testing the quality of generated documents against their highest quality manual examples

This phase required close collaboration between Tyilt's subject matter experts and the Swfte implementation team.

Phase 2: Workflow Integration (1 month)

Once the agents were producing quality documents, Tyilt focused on integrating them into their workflow:

1. Trigger Definition: Specifying when documents should be automatically generated or updated
2. Approval Flow Design: Creating the right balance of automation and human review
3. Notification Setup: Ensuring the right people were alerted at the right time

Tyilt was careful to maintain appropriate human oversight, particularly for compliance-critical documents.

Phase 3: Pilot and Rollout (3 months)

The final phase involved testing and gradually expanding the use of the system:

1. Single Game Pilot: Testing the complete workflow with one game project
2. Measured Expansion: Adding two games per week to the automated system
3. Feedback Loops: Continuously refining the agents based on user feedback
4. Full Deployment: Eventually covering all game projects and documentation types

This phased approach allowed Tyilt to minimize disruption while ensuring the system was delivering the expected benefits.

Results

After a full year of using Swfte for documentation automation, Tyilt achieved impressive results:

Efficiency Gains

• 87% reduction in document creation time (from 12 days to 1.5 days average)
• 92% decrease in format-related revisions
• 23,000+ hours redirected from documentation to creative and development tasks

Quality Improvements

• 98% compliance with regulatory requirements (up from 82%)
• Standardized formatting across all documentation
• Consistent terminology across different game projects
• Automatic updates when regulations changed

Business Impact

The efficiency and quality improvements translated into tangible business benefits:

• 35% faster time-to-market for new game titles
• $2.1M annual savings in direct labor costs
• Zero regulatory penalties since full implementation (down from an average of $350K/year)
• Improved developer satisfaction by eliminating tedious documentation tasks

As Tyilt's CTO put it: "Swfte didn't just save us time—it fundamentally transformed how we approach documentation. What was once a dreaded chore is now a seamless part of our development process."

Key Success Factors

Looking back at their implementation, Tyilt identified several factors that contributed to their success:

1. Starting with High-Value Documents

Rather than trying to automate all documentation at once, Tyilt started with the most time-consuming and frequently created documents:

• Game Design Documents (GDDs)
• Compliance submissions for new jurisdictions
• Monthly regulatory reports

This targeted approach delivered quick wins and built momentum for broader adoption.

2. Human-in-the-Loop Design

Tyilt was careful to maintain human oversight at critical points in the process:

// Example of how they balanced automation and human review
const balancedWorkflow = {
  automated_steps: [
    'initial_draft_generation',
    'format_standardization',
    'terminology_checking',
    'regulatory_requirement_mapping',
  ],
  human_review_steps: [
    'subject_matter_expert_approval',
    'compliance_officer_verification',
    'final_executive_signoff',
  ],
};

This balance ensured quality while still capturing most of the efficiency gains.

3. Continuous Improvement System

Tyilt established a structured process for refining their documentation agents:

• Weekly review of agent-generated documents
• Systematic collection of reviewer feedback
• Monthly retraining with new exemplars
• Quarterly evaluation of time and quality metrics

By treating their agents as evolving products rather than static tools, they achieved continuously improving results.

4. Change Management Focus

Implementing AI agents represented a significant change for Tyilt's teams. Their change management approach included:

• Clear communication about how AI would assist rather than replace team members
• Training sessions on effective collaboration with AI agents
• Recognition of team members who helped improve the system
• Gradual transition of responsibilities as the system proved reliable

This thoughtful approach minimized resistance and accelerated adoption.

Lessons Learned

Tyilt's journey wasn't without challenges. Here are key lessons they shared:

1. Agent specialization matters: Their initial attempt to build a single "universal documentation agent" struggled with the diverse requirements of different document types. Creating specialized agents for each major document category yielded much better results.

2. Knowledge base quality is crucial: The performance of their agents was directly tied to the quality and comprehensiveness of the knowledge they provided. Investing time in building a structured, well-organized knowledge base paid significant dividends.

3. Start with augmentation, not replacement: The most successful implementation approach was to position AI agents as tools to handle the repetitive aspects of documentation, freeing humans to focus on the creative and strategic elements.

4. Governance is essential: Establishing clear oversight procedures for agent-generated content prevented potential issues with accuracy and appropriateness, particularly for regulatory documentation.

5. Integration drives adoption: The more seamlessly the AI agents integrated with existing tools and workflows, the faster teams embraced them.

Looking Forward

Building on their success with documentation, Tyilt is now exploring new applications of Swfte within their organization:

• Game Testing Agents: Automating routine aspects of game testing and bug verification
• Customer Support Assistants: Enhancing player support with AI agents trained on game-specific knowledge
• Marketing Content Generation: Creating localized marketing materials adaptable to different regions
• Analytics Insights: Developing agents that can analyze player behavior and suggest game improvements

As their Chief Innovation Officer notes: "Swfte has become a foundational technology for us. Now that we've seen what's possible with documentation, we're identifying opportunities throughout our business where custom AI agents can drive similar transformations."

Summary

Tyilt's implementation of Swfte for document generation and management demonstrates how custom AI agents can transform even the most document-intensive processes:

• Specialized agents automated routine document creation and updates
• Intelligent workflows connected these agents to existing systems
• Human oversight maintained quality and regulatory compliance
• Continuous improvement ensured ever-better results

The result wasn't just more efficient documentation—it was a fundamental shift in how the company approached documentation, turning it from a bottleneck into a strategic advantage.

For organizations dealing with complex documentation requirements, Tyilt's experience shows that Swfte's custom AI agents offer a powerful way to increase efficiency, improve quality, and free creative talent to focus on higher-value work.

Interested in learning how Swfte could transform your documentation processes? Contact our team to discuss your specific needs and opportunities.