Jumping Agent — Gamified Agent Builder
Build your own AI agent through jump-game gameplay, turning abstract workflows into spatial, tappable steps anyone can use.
- Source repo
- answeryt/Jumping-Agent-platform
- Stars
- ★ 767
- Last updated
- 1mo ago
- License
- Apache-2.0
- Primary language
- TypeScript
- FA score
- 43/100 · Major gaps
At a glance
- How it runs
- Works with
- Portable with changesOpenAI API
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- Non-programmers who want to understand and build a multi-step agent workflow visually on a tablet
- Not a fit if
- Users who want a ready-made agent and won't run three local services manually
- Teams needing a stable production build flow; jump orchestration and final build are unstable
- Source review
- 43/100 · Major gaps 1 safety controls not found
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)
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).
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 does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Jumping Agent — Gamified Agent Builder This agent | 43 · Major gaps | Web appFree + model costs | ★ 767 | 1mo ago | TypeScript | OpenAI API |
| Agently AI Application Runtime | 63 · Some gaps | Library / SDKFree + model costs | ★ 1.7k | 11d ago | Python | OpenAI API · Claude API |
| My Free Code | 54 · Major gaps | Self-hosted serviceFree + model costs | ★ 624 | 4d ago | Python | Claude Code · OpenAI API · Claude API |
| Cezar — AI Coding Agent Orchestrator | 63 · Some gaps | CLIFree | ★ 827 | today | TypeScript | Codex · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
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.
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- 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.