Jumping-Agent: Gamified AI Agent Builder for Tablets and Mobile

Spatial Agent Building Through a Game Interface

Most agent-building tools present workflow construction as a two-dimensional diagram of boxes connected by arrows. Jumping-Agent replaces that with a spatial, gamified interface inspired by a jump-and-land mobile game. Each step of an agent workflow becomes a platform to jump to. The user presses the screen, a piece jumps, and each landing represents one stage in the agent's logic advancing. The README frames this as converting the abstract flow of an agent's execution into something that can be clicked and felt as a sequence.

The platform is designed primarily for tablet use. The README describes the target as zero-background users (the Chinese term is 小白, meaning beginner) who should be able to build a working agent quickly on a mobile device without understanding graphs, nodes, or agent frameworks. Once built, the agent is accessible from WeChat for conversation, which covers a large portion of the target users' daily communication tool.

How the Architecture Connects Front End to Agent

Jumping-Agent runs as three coordinated services. The Front End at port 6301 is a Three.js application that handles the game UI, workflow display, node configuration, chat entry, and WeChat QR code binding. The back_agent at port 8000 is a ReAct agent that reads the skeleton code produced by agent_builder and rewrites it based on user input. The backend orchestrator at port 8001 connects all three: it takes requests from the front end, loads agent_builder, generates an Agent workspace, calls back_agent via HTTP, and provides the WeChat integration API.

The agent_builder directory contains the templates that back_agent uses. It includes flow_template (sequential, routing, and parallel patterns), agent_template (class structures for agent implementations), project_template (the project scaffold), and config_creator (configuration generation). When the user completes a workflow in the game interface, agent_builder produces a skeleton. back_agent then fills in the actual logic using a code completion and rewrite step driven by the user's requirements.

A fourth service, the WeChat bridge at port 8787, is started automatically by the orchestrator when WeChat integration is configured. It handles QR code login, account storage, long-polling, and message routing.

Installing and Starting Jumping-Agent

Prerequisites are Git, Python 3.11 or higher, Node.js 18 or higher, and npm. Clone and enter the repository:

git clone https://github.com/answeryt/Jumping-Agent-platform.git
cd Jumping-Agent-platform

Install the front-end dependencies:

cd Frontend
npm install
cd ..

Create a Python virtual environment and install dependencies:

python -m venv .venv
source .venv/bin/activate
python -m pip install "fastapi" "uvicorn[standard]" "pydantic" "openai"

Set the OpenAI API key before starting services:

export OPENAI_API_KEY="your_api_key_here"

Three terminals are required. Terminal A starts back_agent:

cd back_agent
python -m uvicorn api:app --host 0.0.0.0 --port 8000

Terminal B starts the orchestrator:

cd backend
python -m uvicorn orchestrator:app --host 0.0.0.0 --port 8001

Terminal C starts the front end:

cd Frontend
npm run server -- --host 0.0.0.0 --port 6301 --allowed-hosts all

Access the interface at `http://localhost:6301`. For iPad access from the same local network, use the host machine's LAN IP address instead of localhost.

Connecting the Built Agent to WeChat

After building an agent in the game interface, the user switches to the WeChat tab in the front end. Clicking to generate a QR code triggers a request to the orchestrator's WeChat API, which starts the bridge service at port 8787. Scanning the QR code with WeChat links the account. Once linked, messages sent to that WeChat account are forwarded to the orchestrator, routed to the relevant Agent workspace, and the reply is sent back to WeChat.

The WeChat integration uses an iLink connector for the bridge. The README's description of the relevant modules names three: the front-end WeChat tab and QR display, the orchestrator's WeChat API and bridge auto-start, and the `apps/weixin-main/` connector that handles scan login, account storage, long-polling, and text and media messages.

This design means the agent is accessible to a WeChat user without any additional app installation. The conversational interface the end user sees is ordinary WeChat. The orchestration layer and agent logic run on the developer's local machine or server.

Current Limitations and the Planned CLI

The README is candid about the project's current state. The author describes it as an individual project with limited personal capacity. Two specific limitations are named: the agent workflow only supports 7 templates, and the coordination between the game front end and the final agent code is not yet stable. The README says iteration will continue.

There is no CLI for the startup sequence. Running the project requires three separate terminal processes and a manual install sequence. The README documents a planned CLI:

agent-jump setup
agent-jump config set OPENAI_API_KEY
agent-jump dev

This CLI does not exist yet. Until it does, the manual three-terminal approach in the README is the only supported method.

The LLM backend is wired to OpenAI via `back_agent/config/model_config.toml`. The README mentions that the environment variable `OPENAI_API_KEY` is read by default, but does not document a configuration path for other model providers.

A comparable approach for no-code agent building is n8n, which provides a web-based workflow editor with AI agent nodes and does not require a game interface. Jumping-Agent differs by targeting mobile-first visual construction with direct WeChat delivery, a combination n8n does not offer. The tradeoff is that Jumping-Agent has a smaller template library and less stability.

Editorial conclusion

Jumping-Agent fits developers and educators who want to introduce non-technical users to AI agent construction through a visual, game-based interface, particularly on tablets and within a WeChat-integrated context. Its current limitation is clear in the README, which the author acknowledges: the workflow template library covers only 7 patterns, and the orchestration between the front-end canvas and the final agent code is still unstable. Anyone using it in production should treat it as an early-stage project. Before starting, confirm you have an OpenAI API key, since the back_agent reads OPENAI_API_KEY and the README gives no documentation for alternative LLM backends. The last push was on 2026-09-17 and the repository carries an Apache-2.0 license.

Frequently asked questions

Official sources

1. answeryt/Jumping-Agent-platform on GitHub
2. Issues
3. License: Apache-2.0
4. README