Repository navigation
Replies: 20 comments
|
@alvinunreal originally wrote: Adding this example from a Reddit comment as one concrete workflow pattern to consider: https://www.reddit.com/r/opencode/comments/1txshtw/comment/opzyysp/ Review Panel workflowThe core idea is a configurable review team/panel that the orchestrator can dispatch after each implementation phase. Instead of adding a single reviewer, the workflow would allow something like: fixer → review panel → fixer → review panel
repeat until reviewers pass
then continue to the next implementation phase
final Oracle review only after all phases are completeWhy this is interesting:
A possible workflow pack could define: Review Panel Pack
- runs after each fixer phase
- dispatches N configured reviewers in parallel
- uses the same review prompt or role-specific prompts
- aggregates findings into one actionable report
- sends required fixes back to fixer
- loops until review passes or a max iteration limit is reached
- reserves Oracle for final review / escalationThis is a good example of why this may be more than an "agent catalog". The useful part is not only the extra reviewer agents, but the orchestration rule around when they run, how results are merged, and how the fixer/reviewer loop is controlled. Open questions from this example:
This seems like one of the strongest early candidates for a v3.0 workflow pack. |
|
@alvinunreal originally wrote: Adding another concrete workflow candidate from #358: Janitor / Entropy Audit workflowThis is a good example of a workflow that should probably not be a default always-on agent, but could be very useful as an optional workflow pack. The idea is a maintenance-focused Janitor that does not directly edit code. Instead, it audits the repository for software entropy and produces a safe cleanup plan. Possible triggers:
Example workflow: Janitor audit
→ produce CLEANING_PLAN.md
→ review/safety check by Council or review panel
→ human approval
→ fixer executes approved cleanup tasks
→ validationThe useful part is again not only the custom agent itself, but the orchestration around it:
Possible Janitor responsibilities:
This fits the Workflow Packs idea well because it combines:
Possible pack shape: Janitor Pack
- adds/uses a janitor audit role
- runs manually or after major milestones
- outputs a structured cleaning plan
- routes plan through review/safety checks
- waits for approval before edits
- dispatches approved items to fixer in small batchesOpen questions from this example:
This is another strong v3.0 candidate because it shows why dynamic/custom agents alone may not be enough. The value is in the full workflow: audit → review → approval → execution. |
|
@stevio2d originally wrote: Workflow nameSecurity Gate Pack What it doesAdds a custom safety-focused set of agents and routing rules on top of the default oh-my-opencode-slim setup:
It also adds orchestration rules so these agents run based on surfaced risk, not just because the original request was obviously security-related. When it runs
Agents/models used
Why it is usefulA lot of risky work does not look risky at the start. The useful part of this setup is that it escalates based on what discovery finds, instead of waiting for the user to explicitly ask for security review. It also keeps validation clean by separating implementation from verification. The verifier is not another coding pass. It is a bounded evidence gate. I think this is reusable for people doing auth-heavy apps, infra/config work, or any repo where sensitive changes need stronger guardrails than the default flow. Notes / desired behavior
|
|
@stevio2d originally wrote: Workflow nameWorkflow Support Skill Pack What it doesAdds a small bundle of non-default support skills for workflow-specific work instead of treating everything as generic coding or generic research. In my setup these are:
When it runs
Agents/models usedThis is more of a skill pack than an agent pack. In my setup:
Why it is usefulA lot of useful agent work is not just implementation or review. There is a reusable middle layer for docs maintenance, cleanup, disposable prototyping, planning/handoffs, local config improvement, and security audit prep. I think many users end up recreating these as ad hoc prompt edits, but they feel better as named reusable skills. Notes / desired behavior
Workflow nameRisk-Aware Orchestration Policy What it doesAdds a custom orchestration policy layer on top of the default setup. The main ideas are:
It also distinguishes between startup-configured capabilities, policy-triggered capabilities, explicit opt-in capabilities, and disabled capabilities. When it runs
Agents/models usedThis is mainly an orchestration policy, not a model recommendation. In practice it routes across existing agents plus optional custom gates:
Why it is usefulA lot of multi-agent setups either over-route simple work and make everything expensive, or under-route risky work and jump too quickly from discovery to implementation. This policy tries to keep easy work fast while still adding stronger gates only where the risk justifies it. I think that is reusable as a workflow/policy pack rather than just a personal prompt tweak. Notes / desired behavior
Example of my orchestrator_append.md: |
|
@smatheusblu originally wrote: Workflow nameProject Dashboard What it doesA dashboard with logs, session history, and a kanban board, similar to the one in Hermes. When it runsAs an optional companion view for longer workflows, especially when multiple agents, background tasks, or review/fix loops are involved. Agents/models usedNo specific agents required, but it could surface activity from:
Why it is usefulIt would make longer sessions easier to follow, debug, and resume. Logs would help understand what happened, session history would make previous work easier to recover, and a kanban-style board could show what is pending, in progress, completed, or blocked. Notes / desired behaviorI think a dashboard with logs, session history, and a kanban board similar to the one on Hermes would be awesome, but I do not know if that is too far outside the scope of this project. |
|
@alvinunreal originally wrote: Manager of orchestrators is something to consider |
|
@Zaradacht originally wrote: Workflow nameChat Workflow Packs What it doesI am using a small workflow layer on top of OpenCode/Omo Slim that turns common maintenance tasks into structured chat workflows. The main ones I use are:
Each workflow has a configured questionnaire, readiness gate, defaults, and post-run actions. For example, the comment workflow asks for the target URL and intent, then drafts exactly the requested output while respecting "draft only unless explicitly approved". When it runsAt the start of a maintenance session, before the agent begins work. The workflow picker chooses the task shape first, then asks only the fields needed for that workflow. Agents/models usedUsually:
Why it is usefulIt makes agent sessions much less ambiguous. Instead of every task starting from a free-form prompt, the workflow captures:
The big safety benefit is that destructive or external actions can be separated from drafting/planning. For example, comment workflows never post automatically; they only draft unless the user explicitly approves the exact destination and body. Shared exampleI have also shared this setup in its own repository and published it to npm, so it can already be installed and experimented with as a reusable workflow layer rather than just a private config:
That makes it a useful real-world example for thinking about whether v3.0 should support workflow packs, installable recipes, or community-maintained workflow catalogs. Notes / desired behaviorThis feels like a good fit for optional workflow packs rather than default agents. A future Omo Slim system could ship a few reusable workflow packs such as:
Ideally these would be configurable Markdown/YAML recipes rather than hardcoded agents, so users can add their own required questions, defaults, readiness rules, and post-run actions. |
|
@mhenke originally wrote: Workflow nameLoop Engineering (Execute → Verify → Iterate) What it doesCoordinates existing agents in an iterative execution → verification workflow. An execution agent (for example When it runsManual Potential future triggers could include routines, scheduled jobs, GitHub events, webhooks, or other automation. Agents/models usedExecution
Verification
Escalation
Why it is useful
Notes / desired behavior
This pattern should be reusable beyond code fixing (research, documentation, planning, UI work, etc.) by swapping the execution and verification agents while keeping the same execution → verification → iteration workflow. |
|
@cristisp originally wrote: One thing i would like to have is a way to use different models for the orchestrator based on task complexity. Sometimes I just want a simple fix, where I would not need Opus level reasoning, otherwise I want to plan a complex feature. The only way to switch now is to edit the config file. Is this something that could be implemented somehow? |
|
@w3struk originally wrote: Workflow nameReusable Agent Council Panel What it doesRuns a Council review panel by reusing already configured built-in or custom agents as councillors, instead of requiring a second duplicated The idea is that Council can fan out to existing roles such as This keeps Council presets role-based rather than model-slot-based: users can compose a panel from agents they already tune for normal OpenCode work. When it runsAfter each fixer phase, before moving to the next phase. Also useful before risky refactors, schema migrations, public API changes, architecture decisions, release gates, or any plan that needs multiple specialist perspectives before implementation continues. Agents/models usedThe exact models should come from the active agent configuration instead of being repeated inside the Council preset.
Example desired config: {
"agents": {
"security-reviewer": {
"model": "anthropic/claude-opus-4-6",
"prompt": "You are a security reviewer. Focus on auth, access control, secrets, and unsafe defaults."
},
"db-reviewer": {
"model": "openai/gpt-5.5",
"prompt": "You are a database reviewer. Focus on migrations, indexes, locking, and data integrity."
}
},
"council": {
"default_preset": "backend-risk",
"presets": {
"backend-risk": {
"architecture": { "agent": "oracle" },
"research": { "agent": "librarian" },
"codebase": { "agent": "explorer" },
"database": { "agent": "db-reviewer" },
"security": { "agent": "security-reviewer" }
}
}
}
}Why it is usefulAllows users to build reusable review boards from the agents they already configured, without duplicating model/provider/prompt settings in a parallel Council-only config. This would make Council easier to maintain and easier to share as a workflow pack:
Notes / desired behaviorSuggested backward-compatible councillor config shape: type CouncillorConfig =
| { model: string; variant?: string; prompt?: string }
| { agent: string; variant?: string; prompt?: string };Desired behavior:
Safety expectation: Council should remain advisory / read-only by default. Even when referencing an agent that can normally modify files, Council should not accidentally grant write access, subagent delegation, or interactive question behavior. A safe first implementation could reuse the referenced agent identity, model, variant, options, and prompt, but still apply the current councillor safety envelope: no |
|
@alvinunreal originally wrote: Hater persona #640 (comment) |
|
@MaansenV originally wrote: Workflow nameLive Advisor / Watchdog Reviewer What it doesAdds an optional second model attached to the session that reviews the primary agent transcript after each turn, inspects the workspace with its own read-only tools, and injects concise advice back into the primary session. It is not a second executor: it cannot approve actions or change primary state directly. Default tools are When it runsAfter each primary turn end. The advisor receives only the transcript delta since its last update (thinking, tool calls, and results included), so cost stays bounded instead of re-reviewing the whole conversation every turn. Agents/models used
Why it is usefulMost existing review patterns (panels, verifier gates, council presets) run as a discrete phase after implementation. An advisor reviews continuously and can steer a live turn before the agent yields.
Notes / desired behavior
This complements rather than replaces the discrete review-panel / verifier / council patterns: those run as phases, the advisor runs continuously alongside the primary agent and can catch a hallucinated API or wrong direction before the turn completes. Idea is copied from omp |
|
@alvinunreal originally wrote: per project agent configuration |
|
@ftzi originally wrote:
|
|
@mhenke originally wrote: Workflow nameBackground Debug Agent What it doesUses a running process paired with an MCP as a background debugging agent. You pre-configure breakpoint locations and trigger conditions. The agent blocks until a specific expression is satisfied, then passes the data back to the main agent and retrieves the frame stack. When it runsWhen you want the agent to debug a running process without manually setting breakpoints and waiting for the MCP request to finish. Agents/models used
Why it is usefulLets the agent debug like a human developer would. The main agent can keep working while waiting for the debug condition instead of sitting idle on a synchronous MCP call. Notes / desired behaviorInspired by debug-mcp, but tries to fix two gaps: no conditional breakpoints, and blocking calls that force you to wait. The agent should set breakpoints ahead of time, wait for conditions asynchronously, and pull context when triggered. |
Workflow nameStateful Task Surface What it doesLets a workflow stop being only chat once it starts accumulating structured state. The pack declares a small state contract and a set of allowed actions; the host renders that state as a board, form, table, or chart. A person can edit one constraint or approve one item while the agent keeps working against the same task state. We built this shape as Agentic Mini Apps in BitFun. The useful part turned out not to be generating UI. It was keeping UI actions, tool work, and the conversation attached to the same live state. When it runsFor long workflows with repeated structured input or review: issue triage, release checklists, migration review, research boards. It should not run for a one-shot question just because a generated UI looks impressive. Agents/models usedNo special model. Existing orchestrator and worker agents do the work. The runtime owns state and authorization; the model proposes state changes. Why it is usefulA passive dashboard helps you see what happened. An interactive task surface lets you steer one part of the workflow without writing a large corrective prompt or reconstructing context after reconnecting. The state can also survive a model switch because it does not belong to the model session. Notes / desired behavior
This may expose an important catalog boundary: can a v3 workflow pack reference an optional host capability, or must every pack remain prompts and config only? I would keep the workflow portable and make the interactive surface an optional capability with a text fallback. |
|
Not sure if this was mentioned already here (it's a huge post with lots of words), but I had found #77 which made me wonder on the comment 'should be done by orchestrator'. What I notice as well, is that running tests burns quite a lot of tokens. So the agent has to setup the test (sometimes as simple as docker run) which then generates heaps of output, which needs to be read and parsed, wasting a lot of tokens again. Instead, I can imagine, a very cheap agent (even local 'free' agent) can trigger the tests, monitor the tests, and find the failures to report back to whomever, hoping it would save tokens? So if this usecase is already clearly covered; Ignore or delete my post to remove noise. |
|
@oliv3r - adding validator agent in marketplace, we can tune that |
Uh oh!
There was an error while loading. Please reload this page.
Collection of possible v3.0 ideas around advanced/custom agent workflows.
People are starting to build useful setups on top of the default agents, for example:
I do not want to keep adding more default agents, because that can make the core setup confusing and overwhelming.
Instead, I want to collect ideas around a possible future system for:
The goal here is not to decide the final implementation yet.
For now, this is mainly for collecting examples and feedback.
What to share
If you have a custom workflow, agent setup, or orchestration pattern, please share:
Example format
Early categories
Some possible categories:
Later
Once enough examples are collected, we can decide whether this should become:
For now, please use this to share workflows, custom agents, and setups that you think could help shape a future v3.0 system.
All reactions