Jroute Cli

    1

    Local System-1 CLI meta-router for Claude Code & Antigravity (agy) with automatic sub-model/effort selection and git-free .jrc_context.md shared memory.

    $7

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    jroute-cli

    Example session with this skill installed

    jroute --json "Refactor the database schema to support multi-tenancy in the Odoo module"

    • Read your context and instructions
    • Compiled the jroute-cli

    The system has analyzed the prompt complexity and production risk. Based on the workspace context, it has selected the optimal agent and reasoning parameters.

    Routing Decision Meta-Data

    ParameterValue
    Selected Toolagy (Antigravity)
    Sub-Modelclaude-3-5-sonnet
    Reasoning Effortxhigh
    Complexity Score0.92
    Risk LevelHigh
    ReasoningTask involves structural database changes and multi-tenancy logic, requiring maximum reasoning depth and architectural awareness.
    {
      "routing": {
        "agent": "antigravity",
        "command": "agy",
        "model": "claude-3-5-sonnet",
        "effort": "xhigh",
        "context_sync": true
      },
      "analysis": {
        "intent": "architectural_refactor",
        "entities": ["database", "multi-tenancy", "odoo"],
        "safety_check": "passed"
      }
    }
    

    Next steps

    • Run the command without the --json flag to initiate the agy session.
    • Review .jrc_context.md to ensure the Odoo module structure is correctly indexed.
    • Use /ctx within the jrc REPL to update shared memory after the refactor is complete.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Manually choosing between CLI agents and reasoning models introduces friction and decision fatigue. You often waste high-tier credits on simple git commits or struggle with low-reasoning models on complex architectural refactors.

    What it does

    • Intelligent Routing evaluates prompt complexity and production risk to pick between Claude Code and Antigravity.
    • Dynamic Calibration selects the optimal sub-model and reasoning effort level (low to xhigh) for every task.
    • Shared Memory maintains a git-free .jrc_context.md file to persist task history and architectural notes across different agent sessions.
    • Context Awareness analyzes the current directory, project files, and tech stack markers to provide the router with workspace metadata.
    • Risk Assessment detects high-stakes production tasks to trigger safer tools or higher reasoning models automatically.

    How it works

    1. Initialize the workspace context by running jrc or jroute in your project root to generate the shared memory layer.
    2. Input your prompt directly via jroute "task" or enter the interactive jrc REPL for a multi-turn session.
    3. Review the automated routing decision, where the Jev SDK calculates tool fit and model effort based on your local Ollaya server's analysis.
    4. Execute the task as the router launches the chosen CLI agent with the pre-configured model flags and shared context.

    Frameworks & tools

    Built with Python and the TypeSafe AI Jev SDK. It integrates directly with Claude Code, Antigravity (agy), and local Ollaya servers for private, local-first decision routing.

    Why this beats prompting it yourself

    Manual selection is reactive and inconsistent. This skill uses a dedicated System-1 logic layer to make objective decisions on tool fit and reasoning depth before the expensive agent even starts, saving both time and API tokens.

    Use cases

    • Route simple git operations to low-cost models while sending complex debugging to high-reasoning agents.
    • Persist project knowledge between Claude Code and Antigravity sessions using a local memory file.
    • Prevent production accidents by automatically escalating reasoning effort for high-risk infrastructure prompts.
    • Test routing logic using the --dry-run or --json flags to see model probability distributions.

    Known limitations

    Requires a local Ollaya server running at the specified port and pre-installed Claude Code or Antigravity binaries. Shared memory relies on MD5 diffing which may be slow in massive directories.

    Requires local Ollaya server at port 11435. Claude Code and Antigravity binaries must be globally accessible. Shared memory MD5 diffing may lag in very large repositories.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 2 days ago

    Requires

    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables
    Listed2 days ago

    What's inside

    Frequently Asked Questions

    jroute cli acts as an intelligent traffic controller that analyzes your task's complexity and risk level to automatically launch either Claude Code or Antigravity, preventing you from wasting expensive tokens on simple tasks or using underpowered models for complex refactors.

    This skill integrates directly with Claude Code and Antigravity (agy), utilizing a local Ollaya server to handle the underlying routing logic and model effort calibration.

    The shared memory feature uses a local `.jrc_context.md` file to track architectural notes and task history, allowing you to switch between different agents without losing context or project-specific knowledge.

    You will need a Python environment, the Claude Code and Antigravity binaries already installed, and a local Ollaya server running to handle the routing analysis.

    Yes, you can use the `--dry-run` or `--json` flags to see the routing probability distributions and model effort levels before any API calls are actually executed by the agents.

    Your purchase includes the jroute CLI tool built on the TypeSafe AI Jev SDK, comprehensive documentation, and access to future version updates as new agents are added to the routing logic.

    New in Agents & Orchestration