JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.
Modes
JiuwenSwarm supports multiple runtime modes, each with its own tool set, permission policy, and memory behavior. Users can switch modes during a conversation using the /mode command.
Mode Overview
| Mode | Code | Description |
|---|---|---|
| Agent (Plan) | agent.plan |
Default mode. Full tools + proactive memory, focused on reasoning and planning |
| Agent (Fast) | agent.fast |
Full tools + passive memory, focused on quick responses |
| Code (Normal) | code.normal |
Code mode + coding memory, focused on code execution |
| Code (Team) | code.team |
Team collaboration launched from the Code profile |
| Team | team |
Multi-agent collaboration mode, based on the team definition in config |
Switching Modes
Use the following commands during a channel conversation:
/mode agent # Switch to Agent mode (defaults to agent.plan)
/mode plan # TUI local shorthand, equivalent to agent.plan
/mode code # Switch to Code mode (defaults to code.normal)
/mode team # Switch to Team mode
/mode agent.plan # Switch directly to Agent Plan sub-mode
/mode agent.fast # Switch directly to Agent Fast sub-mode
/mode code.normal # Switch directly to Code Normal sub-mode
/mode code.team # Switch directly to Code Team sub-mode
/mode team.normal # TUI local form, equivalent to team
Compatibility:
/mode planand/mode team.normalare TUI-local command forms. Gateway controlled channels acceptagent,code,team,agent.plan,agent.fast,code.normal, andcode.team.
You can also use /switch to change sub-modes within the same category:
/switch plan # Under Agent → plan; under Code → plan
/switch fast # Under Agent → fast
/switch normal # Under Code → normal
/switch team # Under Code → code.team
The TUI source contains a
/switchimplementation, but the default TUI command registry does not currently register it. In TUI, prefer/mode ...for direct switching or/planto enter Agent plan mode.
Configuration
Define mode tools and constraints in the modes section of config/config.yaml:
modes:
agent:
fast:
memory:
enabled: true
is_proactive: false # Passive memory
rails: []
tools: []
plan:
memory:
enabled: true
is_proactive: true # Proactive memory
rails: []
tools: []
code:
rails:
- FileSystemRail # File system safety rails
- SkillUseRail # Skill invocation rails
- LspRail # LSP assistance rails
tools:
- web_free_search
- web_fetch_webpage
- web_paid_search
- user_todos
embedding_config:
model_name: null
base_url: null
api_key: null
team:
jiuwen_team:
team_name: jiuwen_team
lifecycle: persistent
teammate_mode: build_mode
spawn_mode: inprocess
leader:
member_name: team_leader
display_name: Team Leader
persona: "Expert project manager, skilled at task decomposition and team coordination"
agents:
leader:
workspace:
stable_base: true
max_iterations: 200
completion_timeout: 600.0
workspace:
enabled: true
transport:
type: inprocess
storage:
type: sqlite
Section Reference
| Path | Description |
|---|---|
modes.agent.fast |
Agent Fast mode: passive memory, no extra rails |
modes.agent.plan |
Agent Plan mode: proactive memory, no extra rails |
modes.code.rails |
Dynamic safety rails for Code mode (fixed rails are hardcoded) |
modes.code.tools |
Dynamic tool whitelist for Code mode (coding_memory_* and send_file_to_user are registered at runtime) |
modes.code.embedding_config |
Code-mode-specific embedding config (empty = use global) |
modes.team.<name> |
Team mode definition: team name, lifecycle, leader/agents config |
Channel Default Mode
Each channel can specify a default mode via channels.<channel>.default_mode in config.yaml:
channels:
web:
enabled: true
default_mode: agent.plan # This channel defaults to Agent Plan mode
Mode Behavior Differences
Modes do more than rename the UI state: they decide which AgentServer runtime profile is used, which Rails are attached, and how memory or team coordination is injected.
| Mode | Runtime profile | Agent behavior focus | Main Rails / tool differences | Memory strategy |
|---|---|---|---|---|
agent.plan |
Deep Agent (mode=agent, sub_mode=plan) |
Default planning-oriented chat. Best for complex task decomposition, long reasoning, skill evolution, and tasks that benefit from subagents. | Registers TaskPlanningRail and SubagentRail; enables SkillEvolutionRail / SkillCreateRail when configured; keeps normal Agent tools such as search, multimodal tools, and skills. |
Uses modes.agent.plan.memory; defaults to proactive memory (is_proactive: true) so context is retrieved and consolidated more actively. |
agent.fast |
Deep Agent (mode=agent, sub_mode=fast) |
Fast response mode. Less orchestration, more direct answering or tool use on demand. | Unregisters TaskPlanningRail, SkillEvolutionRail, SkillCreateRail, and SubagentRail; keeps common runtime prompt, safety, permission, search/multimodal/skill tooling. |
Uses modes.agent.fast.memory; defaults to passive memory (is_proactive: false) and usually reads/writes memory on demand. |
code.normal |
Code Adapter (mode=code, sub_mode=normal) |
Execution phase for coding work. Useful for editing files, running commands, verifying changes, and delivering results. | Uses the Code-specific English system prompt; fixed Rails include LspRail, ProjectMemoryRail, CodingMemoryRail, AgentModeRail, StructuredAskUserRail, ConfirmInterruptRail, filesystem/permission Rails; dynamic Rails/tools come from modes.code.rails / modes.code.tools. |
Uses CodingMemoryRail and project memory files such as JIUWENSWARM.md / CLAUDE.md. |
code.team |
Code Adapter + Team sub-mode (mode=code, sub_mode=team) |
Team collaboration launched from the Code profile. Useful when a coding project needs multiple members to split work while preserving code-workspace semantics. | The main agent stays on the Code profile; TeamManager starts team members and attempts to inherit the Code-side project directory, code tooling, and member skill toolkit. | Team members follow Team config; code/project context is influenced by both the Code profile and Team runtime. |
team |
Team runtime (mode=team) |
Standard multi-agent collaboration. A leader decomposes, schedules, and summarizes work while role members execute subtasks. | Team members attach Rails such as RuntimePromptRail, ResponsePromptRail, SysOperationRail, TaskPlanningRail, SecurityRail, HeartbeatRail, and AvatarPromptRail; the leader additionally supports Team skill evolution/creation; tools come from the inheritable whitelist and team config. |
Controlled by modes.team.<name>.memory, including shared TEAM_MEMORY.md, auto-extraction, and member memory prompt injection. |
Quick Mental Model
agent.planandagent.fastuse the same Deep Agent profile, butagent.plankeeps planning, subagent, and skill-evolution Rails whileagent.fastremoves those heavier orchestration pieces.code.teamandteamboth enter team collaboration, but from different entry points:code.teamstarts from the Code profile and is better for code-project delegation;teamis the standard Team runtime.
See Also
- Configuration — Full
modessection field reference inconfig.yaml - CLI Commands — Full command reference including
/modeand/switch - Slash Command Architecture — Internal command parsing flow
- Distributed Team — Distributed deployment for Team mode