Jumping Agent — Gamified Agent Builder
Build your own AI agent through jump-game gameplay, turning abstract workflows into spatial, tappable steps anyone can use.
Evidence is limited to README, LICENSE, and three test files. The only visible security-relevant facts: services bind to 0.0.0.0, WeChat QR-code account binding, API keys written to .env. No code shown proves least privilege, user confirmation, data-flow documentation, or rollback; tests showing generated files are not overwritten ('# sentinel') are a small positive for safe generation. Most criteria score 1; rollback scores 0 with no evidence. source_attribution: the author explicitly states solo development and gives contact channels, scoring 2.
README claims (WeChat bridge, orchestrator, workspace) have no supplied source to back them, so they remain assertions; dependency install is ad-hoc pip install with no requirements.txt or lockfile, so 1; failure handling appears only in isolated test strings (e.g. 'build_plan. is not valid JSON'), so 1.
Audience and scenario are clearly stated (zero-experience users, tablet-first, WeChat channel), so 2; the author honestly discloses limits (7 templates, unstable build flow), so 2; environment_fit has prerequisites, cross-platform commands, and LAN/iPad notes, so 2; trigger_precision is not addressed anywhere in the visible material, so 0.
Information architecture is good (directory tree plus mermaid diagram), so 2; install steps are complete and followable, so 2; known limitations are explicitly stated, so 2; LICENSE is full Apache-2.0 text, so 3. But naming is unstable (misspellings like creat_project, run_time_templete appear in real paths), so 1; no FAQ and only one video as example, so 1; no changelog or versioning, so 0; maintenance is a personal promise ('I will keep iterating') without governance, so 1.
output_usability: the end product is a WeChat-chatable Agent, but workspace operation and output format are thinly described in visible evidence, so 1; marginal_value: gamified spatial agent building is a genuinely differentiated idea, so 2; cost_benefit: requires your own OpenAI key, three terminals, and self-admitted instability, so 1.
claim_traceability is weak: core selling points (WeChat bridge, orchestration) cannot be traced to supplied code, so 1; cross_source_corroboration is limited: tests only corroborate the agent_builder scaffolding logic, not the rest, so 1; fact/inference separation is good: the CLI is clearly labeled a plan and limitations are candidly listed, so 2.
- All services bind to 0.0.0.0 by default; anyone on the LAN can reach the orchestrator and chat endpoints. Rebind to 127.0.0.1 or add authentication on untrusted networks.
- WeChat QR binding links a personal WeChat account into an automated reply path; credential storage and data flow are undocumented in the visible material — assess risk yourself.
- No dependency lockfile exists, so known-vulnerability status of pinned versions cannot be verified statically.
- No rollback/uninstall guidance; generated workspace files are not overwritten, but no deletion/recovery mechanism is provided.
- The author admits the build flow is unstable, and there is no changelog or versioning — use with caution beyond experimentation.
- This is a static review; no code was executed, and the actual behavior of the WeChat bridge and orchestrator is unverified.
What does this agent do, and when should you use it?
Jumping Agent is an open-source (Apache-2.0) agent-building platform that replaces conventional flat workflow editors with a 'jump-jump' game-style spatial interface, aimed at beginners and prioritizing tablets for mobile use. In a Three.js jump-platform UI, users build flows by tapping to hop through steps; backend/orchestrator.py then orchestrates calls to agent_builder templates and the ReAct agent in back_agent, which completes and rewrites skeleton code to produce a runnable Agent workspace. Once built, users can bind a WeChat account via QR scan and chat with their agent directly in WeChat, with messages relayed through the apps/weixin-main iLink connector and the Weixin bridge on port 8787. The system is fully self-hosted, requiring three local services — back_agent on port 8000, the orchestrator on port 8001, and the frontend on port 6301 — plus an OPENAI_API_KEY. The project is developed solo by its author, who notes the current version offers only 7 workflow templates and that the jump-platform orchestration and final build flow are not yet fully stable.
In the Frontend/ Three.js jump-game interface, users pick a flow template (sequential, routing, parallel, etc., from agent_builder/flow_template/) and describe their needs. orchestrator.py receives the request, loads agent_builder skeletons and templates, calls back_agent's ReAct agent over local HTTP to complete and rewrite the skeleton code, and generates a workspace in backend/workspace/ containing Agent/*.py files and project_runtime.py. On the WeChat path, apps/weixin-main provides iLink QR login, account storage, long polling, and text/media messaging; the Weixin bridge forwards messages to the orchestrator's /chat endpoint, which runs the matching workspace and sends replies back to WeChat. The backend also ships MCP tools (web, image, session), session and long-term memory, and agent ID management.
- Non-programmers who want to understand and build a multi-step agent workflow visually on a tablet
- Developers who want to scaffold an agent project with sequential, routing, or parallel flow structures and then edit the code themselves
- WeChat users who want to converse with their built agent directly inside WeChat without installing anything
- Educators or presenters who need to demonstrate agent execution dynamically as a gamified jump-platform sequence
- Individual developers looking to extend generated agents with local MCP tools (web, image, session)
What are this agent's strengths and limitations?
- Gamified jump-game interaction sharply lowers the barrier to agent building, with a tablet-first mobile design that avoids complex node-and-arrow diagrams
- Fully automated from template to runnable code: back_agent's ReAct agent completes and generates the workspace project
- WeChat is a formally integrated channel — QR binding then direct chat, with text/media messaging and long polling
- Clean modular architecture: frontend, template building, ReAct completion, orchestration, and WeChat bridging are clearly separated, with MCP tools and memory modules
- The author states only 7 workflow templates exist and that jump-platform orchestration and the final build flow are not yet stable
- Strong dependence on an OpenAI-compatible API (OPENAI_API_KEY), with no documented adapters for other model providers
- Three services must be started manually (ports 8000/8001/6301); the CLI is only a plan and not implemented
- WeChat integration relies on the iLink connector and Weixin bridge — ecosystem-specific binding; other channels require custom development
How do you install or deploy this agent?
- Clone: git clone https://github.com/answeryt/Jumping-Agent-platform.git && cd Jumping-Agent-platform
- Install frontend deps: cd Frontend && npm install && cd ..
- Create and activate a Python virtualenv: python -m venv .venv (Windows: .venv\Scripts\activate; macOS/Linux: source .venv/bin/activate)
- Install backend deps: python -m pip install "fastapi" "uvicorn[standard]" "pydantic" "openai"
- Install WeChat connector deps: cd apps/weixin-main && npm install && cd ../..
- Configure the key: set the OPENAI_API_KEY environment variable, or run python backend/set_agent_api_key.py to write .env files
Prerequisites: Git, Python 3.11+, Node.js 18+, npm.
How do you use this agent?
Open three terminals from the repo root:
Terminal A — start back_agent: cd back_agent && python -m uvicorn api:app --host 0.0.0.0 --port 8000
Terminal B — start the orchestrator (auto-starts the Weixin bridge): cd backend && python -m uvicorn orchestrator:app --host 0.0.0.0 --port 8001
Terminal C — start the frontend: cd Frontend && npm run server -- --host 0.0.0.0 --port 6301 --allowed-hosts allVisit http://localhost:6301. Build your agent in the jump-game UI, switch to the WeChat tab to get a QR code and scan it, then chat with your agent in WeChat. For iPad access, be on the same LAN and use your computer's LAN IP (e.g., http://192.168.x.x:6301).