Cloud Challenges

Engage with coding challenges, earn credits, track achievements, and compete on leaderboards in Flow Nexus.

Quick Start

javascript

// Browse available challenges
const challenges = await mcp__flow-nexus__challenges_list({
  difficulty: "intermediate",
  category: "algorithms",
  status: "active"
});

// Get challenge details
const challenge = await mcp__flow-nexus__challenge_get({
  challenge_id: "challenge_id"
});

// Submit solution
await mcp__flow-nexus__challenge_submit({
  challenge_id: "challenge_id",
  user_id: "user_id",
  solution_code: "function solve(input) { return input.sort(); }",
  language: "javascript"
});

// Check leaderboard
const leaderboard = await mcp__flow-nexus__leaderboard_get({
  type: "global",
  limit: 10
});

When to Use

Finding coding challenges to improve skills
Submitting solutions for validation and scoring
Tracking personal achievements and badges
Competing on global and challenge-specific leaderboards
Earning rUv credits through challenge completion
Following learning paths for skill development

Prerequisites

Flow Nexus account with active session
Basic programming knowledge
Sandbox access for testing solutions

Core Concepts

Difficulty Levels

Level	Description	Credits
Beginner	Basic concepts, simple algorithms	10-50
Intermediate	Data structures, moderate complexity	50-100
Advanced	Complex algorithms, optimization	100-250
Expert	System design, cutting-edge problems	250-500

Challenge Categories

Category	Focus
Algorithms	Classic algorithm problems
Data Structures	Implementation and optimization
System Design	Scalable architecture
Optimization	Performance-focused problems
Security	Cryptography, vulnerability analysis
ML Basics	Machine learning fundamentals

Gamification Features

Dynamic Scoring: Based on code quality, efficiency, creativity
Achievement Badges: Progressive unlocks for accomplishments
Learning Streaks: Rewards for consistent engagement
Leaderboards: Global, weekly, monthly, per-challenge

MCP Tools Reference

Challenge Discovery

javascript

// List challenges
mcp__flow-nexus__challenges_list({
  difficulty: "intermediate",  // beginner, intermediate, advanced, expert
  category: "algorithms",      // algorithms, data_structures, system_design, etc.
  status: "active",            // active, completed, locked
  limit: 20                    // Max results (1-100)
})
// Returns: { challenges: [{ id, title, difficulty, category, credits }] }

// Get challenge details
mcp__flow-nexus__challenge_get({
  challenge_id: "challenge_id"
})
// Returns: { id, title, description, examples, constraints, credits, time_limit }

Solution Submission

javascript

mcp__flow-nexus__challenge_submit({
  challenge_id: "challenge_id",
  user_id: "user_id",
  solution_code: "function solve(input) { /* solution */ }",
  language: "javascript",       // javascript, python, go, rust, etc.
  execution_time: 45            // Optional: time taken in ms
})
// Returns: { passed, score, test_results, credits_earned, feedback }

Challenge Completion

javascript

mcp__flow-nexus__app_store_complete_challenge({
  challenge_id: "challenge_id",
  user_id: "user_id",
  submission_data: {
    solution_code: "...",
    time_taken: 120,
    attempts: 2
  }
})
// Returns: { completed, credits_awarded, achievements_unlocked }

Achievements

javascript

mcp__flow-nexus__achievements_list({
  user_id: "user_id",
  category: "speed_demon"       // Optional category filter
})
// Returns: { achievements: [{ id, name, description, earned_at }] }

Leaderboards

javascript

mcp__flow-nexus__leaderboard_get({
  type: "global",              // global, weekly, monthly, challenge
  challenge_id: "id",          // Required for type="challenge"
  limit: 10                    // Max entries (1-100)
})
// Returns: { rankings: [{ rank, user, score, challenges_completed }] }

Earning Credits

javascript

mcp__flow-nexus__app_store_earn_ruv({
  user_id: "user_id",
  amount: 100,
  reason: "Challenge completion: Binary Search Tree",
  source: "challenge"
})
// Returns: { new_balance, credits_earned }

Usage Examples

Example 1: Finding and Solving a Challenge

javascript

// Browse available challenges for your skill level
const challenges = await mcp__flow-nexus__challenges_list({
  difficulty: "intermediate",
  category: "algorithms",
  status: "active",
  limit: 10
});

console.log("Available Challenges:");
for (const c of challenges.challenges) {
  console.log(`- ${c.title} (${c.difficulty}): ${c.credits} credits`);
}

// Get details for a specific challenge
const challenge = await mcp__flow-nexus__challenge_get({
  challenge_id: challenges.challenges[0].id
});

console.log(`
Challenge: ${challenge.title}
--------------------------
${challenge.description}

Examples:
${challenge.examples.map(e => `Input: ${e.input} → Output: ${e.output}`).join('\n')}

Constraints:
${challenge.constraints.join('\n')}

Time Limit: ${challenge.time_limit}ms
Credits: ${challenge.credits}
`);

// Test solution in sandbox first (recommended)
const sandbox = await mcp__flow-nexus__sandbox_create({
  template: "node"
});

const testResult = await mcp__flow-nexus__sandbox_execute({
  sandbox_id: sandbox.sandbox_id,
  code: `
    function solve(input) {
      // Your solution here
      return input.sort((a, b) => a - b);
    }
    console.log(solve([3, 1, 4, 1, 5, 9]));
  `,
  language: "javascript"
});

// Submit solution
const submission = await mcp__flow-nexus__challenge_submit({
  challenge_id: challenge.id,
  user_id: "your_user_id",
  solution_code: "function solve(input) { return input.sort((a, b) => a - b); }",
  language: "javascript"
});

if (submission.passed) {
  console.log(`\nChallenge Passed! Score: ${submission.score}`);
  console.log(`Credits Earned: ${submission.credits_earned}`);
} else {
  console.log("\nSome tests failed:");
  for (const result of submission.test_results) {
    if (!result.passed) {
      console.log(`- Test ${result.id}: ${result.feedback}`);
    }
  }
}

Example 2: Tracking Progress and Achievements

javascript

// Get your achievements
const achievements = await mcp__flow-nexus__achievements_list({
  user_id: "your_user_id"
});

console.log("Your Achievements:");
for (const a of achievements.achievements) {
  console.log(`🏆 ${a.name} - ${a.description}`);
  console.log(`   Earned: ${a.earned_at}`);
}

// Achievement categories
const categories = ["speed_demon", "problem_solver", "streak_master", "explorer"];

for (const category of categories) {
  const catAchievements = await mcp__flow-nexus__achievements_list({
    user_id: "your_user_id",
    category: category
  });

  console.log(`\n${category.replace('_', ' ').toUpperCase()}:`);
  console.log(`- Earned: ${catAchievements.achievements.length} achievements`);
}

Example 3: Competing on Leaderboards

javascript

// Global leaderboard
const globalBoard = await mcp__flow-nexus__leaderboard_get({
  type: "global",
  limit: 10
});

console.log("🌍 Global Leaderboard:");
for (const entry of globalBoard.rankings) {
  console.log(`#${entry.rank} ${entry.user} - ${entry.score} pts (${entry.challenges_completed} challenges)`);
}

// Weekly leaderboard
const weeklyBoard = await mcp__flow-nexus__leaderboard_get({
  type: "weekly",
  limit: 10
});

console.log("\n📅 This Week's Top Performers:");
for (const entry of weeklyBoard.rankings) {
  console.log(`#${entry.rank} ${entry.user} - ${entry.score} pts`);
}

// Challenge-specific leaderboard
const challengeBoard = await mcp__flow-nexus__leaderboard_get({
  type: "challenge",
  challenge_id: "specific_challenge_id",
  limit: 10
});

console.log("\n🎯 Challenge Leaderboard:");
for (const entry of challengeBoard.rankings) {
  console.log(`#${entry.rank} ${entry.user} - ${entry.score} pts (${entry.execution_time}ms)`);
}

Example 4: Learning Path Progression

javascript

// Start with beginner challenges
const beginnerChallenges = await mcp__flow-nexus__challenges_list({
  difficulty: "beginner",
  category: "algorithms"
});

console.log("📚 Learning Path: Algorithms");
console.log("Step 1: Beginner Challenges");

let completedCount = 0;
for (const challenge of beginnerChallenges.challenges.slice(0, 5)) {
  console.log(`- ${challenge.title} (${challenge.credits} credits)`);
}

// Progress to intermediate after completing beginner
if (completedCount >= 5) {
  const intermediateChallenges = await mcp__flow-nexus__challenges_list({
    difficulty: "intermediate",
    category: "algorithms"
  });

  console.log("\n🎯 Step 2: Intermediate Challenges Unlocked!");
  for (const challenge of intermediateChallenges.challenges.slice(0, 5)) {
    console.log(`- ${challenge.title} (${challenge.credits} credits)`);
  }
}

Execution Checklist

Browse challenges matching your skill level
Read challenge description and constraints carefully
Test solution in sandbox before submitting
Submit solution for validation
Review feedback if tests fail
Collect credits on successful completion
Check for unlocked achievements
Review leaderboard position

Best Practices

Start at Your Level: Begin with beginner challenges, progress gradually
Understand First: Read problem statement completely before coding
Test Locally: Use sandbox to test before submitting
Optimize After: Get it working first, then optimize
Learn from Failures: Use feedback to improve solutions
Maintain Streaks: Consistent daily practice builds skills

Scoring Criteria

Criterion	Weight	Description
Correctness	50%	All test cases pass
Efficiency	25%	Time and space complexity
Code Quality	15%	Clean, readable code
Creativity	10%	Novel approaches

Error Handling

Error	Cause	Solution
`challenge_not_found`	Invalid challenge_id	Use `challenges_list` to find valid IDs
`submission_failed`	Runtime error or timeout	Check code syntax and efficiency
`time_limit_exceeded`	Solution too slow	Optimize algorithm complexity
`wrong_answer`	Incorrect output	Review logic and edge cases
`compilation_error`	Invalid syntax	Fix syntax errors

Metrics & Success Criteria

Completion Rate: Target >70% first-attempt success
Average Score: Target >80/100 on solved challenges
Streak Days: Maintain 7+ day streaks
Rank Progress: Improve leaderboard position weekly

Integration Points

With Sandboxes

javascript

// Test solution in isolated environment
const sandbox = await mcp__flow-nexus__sandbox_create({
  template: "node"
});

await mcp__flow-nexus__sandbox_execute({
  sandbox_id: sandbox.sandbox_id,
  code: solutionCode
});

With Payments

javascript

// Credits earned from challenges
const balance = await mcp__flow-nexus__check_balance();
console.log(`Total credits from challenges: ${balance.challenge_earnings}`);

Related Skills

cloud-sandbox - Test solutions
cloud-payments - Track earnings
cloud-auth - User management

References

Version History

1.0.0 (2026-01-02): Initial release - converted from flow-nexus-challenges agent

Search AI Tools

cloud-challenges

Install this agent skill to your Project

SKILL.md

Cloud Challenges

Quick Start

When to Use

Prerequisites

Core Concepts

Difficulty Levels

Challenge Categories

Gamification Features

MCP Tools Reference

Challenge Discovery

Solution Submission

Challenge Completion

Achievements

Leaderboards

Earning Credits

Usage Examples

Example 1: Finding and Solving a Challenge

Example 2: Tracking Progress and Achievements

Example 3: Competing on Leaderboards

Example 4: Learning Path Progression

Execution Checklist

Best Practices

Scoring Criteria

Error Handling

Metrics & Success Criteria

Integration Points

With Sandboxes

With Payments

Related Skills

References

Version History