Plan, coordinate, and review work across models.
Break complex model work into visible steps. Plan the task, coordinate worker lanes, verify the result, and keep receipts so multi-step work can be reviewed before it moves forward. It gives larger jobs a visible operating shape: a planner frames the work, worker lanes handle bounded tasks, verification checks the result, and the workspace keeps the reasoning trail close by. The emphasis is on inspectable context and coordination, not on mysterious automation or unsupported claims about long-term training or retention.
Result capped at MAX_WORKERS = 2. Cloud provider models run in preview injection mode.
Ethen is the orchestration workspace for complex model work that needs structure, review, and evidence.
Some tasks are too large for a single prompt and too important to leave as a hidden chain of actions. Ethen gives complex work a visible operating shape: a planner defines the path, workers handle scoped steps, a verifier checks the result, and receipts stay attached to the run. The goal is not invisible autonomy. The goal is reviewable orchestration inside one model workspace. The workspace can carry project context, prior artifacts, approval history, and route choices forward so complex work feels continuous rather than fragmented, while still letting the user inspect what each step had access to.
Why it exists
Complex work needs a visible system.
When a model task spans research, coding, drafting, review, and approval, the user needs more than a long answer. They need to see the plan, the boundary of each step, the model lane used, the evidence gathered, and the verification pass before trusting the result. When work grows past one answer, the user needs a clearer structure than a single chat response can provide. A planner, a set of bounded tasks, and a verification layer make complex jobs easier to read, challenge, and improve.
- Turn broad requests into reviewable task plans. Complex work benefits from a map before it benefits from speed.
- Coordinate scoped worker steps without hiding the workflow boundary. Separate roles help keep large jobs from collapsing into one noisy pass.
- Verify outputs against the original goal before presenting the result. Verification matters because orchestration should surface uncertainty, not hide it.
- Keep receipts, assumptions, and decisions connected to the workspace history. Approvals still matter when a workflow spans many steps or tools.
What you can do
What could orchestration organize?
Use orchestration when the work has multiple stages and each stage needs a clear role, lane, and review point. The page should make multi-step work feel understandable. It is not about claiming that the system remembers everything forever. It is about carrying the right context, receipts, and decisions through a job in a way the user can still inspect.
Decompose a task
Prompt
Break this product launch task into planner, research, copy, review, and approval steps.
Result
A structured task plan with step boundaries, model-lane suggestions, review points, and expected receipts. The result should show what the planner learned first and what still needs a worker pass.
Coordinate workers
Prompt
Assign separate worker passes for market research, product copy, proof review, and final synthesis.
Result
A coordinated workflow outline that keeps each worker scoped and keeps the final synthesis tied to evidence. A good decomposition should explain why the job is being split and what each step owns.
Verify the output
Prompt
Check the final brief against the original request, open questions, and proof requirements.
Result
A verifier pass that separates accepted work, uncertain claims, missing evidence, and approval needs. Verification should compare the result against the plan, not only against style preferences.
Keep receipts
Prompt
Show the evidence trail for this workflow: sources, assumptions, model lanes, decisions, and unresolved items.
Result
A receipt view that makes the path from request to result easier to inspect and repeat. The review should identify where the coordination logic or approval boundaries need tightening.
Example workspace
A complex task becomes a visible run.
Scenario
A founder wants a launch package that includes positioning, landing-page copy, announcement copy, proof checks, and a signoff review pass. The work is broad enough that one prompt would blur the responsibilities.
Cortex workspace · launch package
Plan and coordinate a launch package. Use separate worker passes for research, page copy, proof review, and final synthesis. Keep receipts and approval needs visible. Show the planner view, worker roles, verification checkpoints, and the context each stage depends on.
Execution steps
- 1Creates a planner brief with the goal, constraints, expected outputs, and review boundaries. So the job is framed before effort spreads out.
- 2Splits the work into scoped worker steps for research, copy, proof review, and synthesis. Each subtask should stay narrow enough to review.
- 3Suggests model lanes for each step based on reasoning need, volume, and privacy posture. Model-lane choice is part of the coordination story.
- 4Runs a verification pass against the original goal and flags claims that need evidence. Verification should test the plan against the output.
- 5Presents the final package with receipts, open questions, and approval needs attached. The user should be able to see the chain without reading everything twice.
Core Workflows
Core orchestration workflows
Ethen is built for multi-step model work where clarity matters as much as output quality. Orchestration is useful when the work needs roles, handoffs, checks, and a memory of what already happened inside the same workspace.
Task planning
Turn broad goals into structured plans with inputs, constraints, expected outputs, review checkpoints, and model-lane suggestions. Planning helps the user decide whether the task is even ready to run.
Worker coordination
Break work into scoped worker passes so research, drafting, coding, review, and synthesis do not collapse into one opaque answer. Worker passes keep subtasks scoped enough to verify.
Verification
Review the final output against the original request, known constraints, proof requirements, and unresolved questions. Verification makes the process safer and more useful.
Receipts
Keep evidence, decisions, assumptions, model-lane choices, and step outputs attached to the run. Workspace context helps the system build on prior decisions without losing the trail.
Traceable execution
Make the path of a complex workflow visible enough to inspect, pause, revise, or repeat. Approval checkpoints matter because not every coordinated result should move forward automatically.
Approval-based boundaries
Mark sensitive or state-changing steps clearly so they can pause for user approval before moving forward. Evidence keeps the whole chain reviewable later.
Model Lanes
Use the right model lane
Ethen can coordinate different model lanes inside one workflow. The lane choice should be visible for each step, not buried inside the result. The value is not only that different lanes can be used. The value is that each lane can have a visible job in the overall plan.
Flagship models
Use for complex reasoning, planning, synthesis, and review where judgment quality matters most. Often best for planning, synthesis, and difficult judgment calls.
Open models
Use for fast iteration, drafting, extraction, transformation, and cost-aware repeated work. Helpful for drafting subtasks, extraction passes, or volume work inside a broader plan.
Local models
Use for sensitive context, private review, and controlled experimentation where local lanes are supported. Useful where a configured private lane should handle sensitive context before the result returns to the shared workspace.
Where it works
Where orchestration fits
Ethen orchestration is useful when work spans more than one model call, more than one skill, or more than one review stage. It fits when the task spans multiple kinds of reasoning and the user wants the chain of work to stay legible.
Product launches
Plan positioning, copy, assets, proof checks, and approval steps in one orchestration workspace. Launch packages, research projects, and larger implementation efforts often need this shape.
Research briefs
Separate gathering, synthesis, fact checks, and final writing so the evidence stays visible. The system is especially useful when different subtasks deserve different model lanes.
Engineering workflows
Coordinate planning, code review, validation notes, and release summaries with receipts attached. Verification-heavy work benefits when checks are first-class steps.
Operations processes
Organize recurring work into planner, worker, verifier, and approval steps before it becomes a saved workflow. Approval-heavy work benefits when the orchestration path is easy to inspect.
Workflow
A reviewable orchestration path
Ethen is designed to keep complex model work inspectable from first plan to final output. Complexity is easier to trust when each stage has a job, a boundary, and a record.
Define the goal, constraints, evidence needs, and approval boundaries. Frame the goal and define the success condition.
Decompose the task into scoped worker steps. Split the work into bounded stages with clear ownership.
Choose a model lane for each step based on reasoning need, speed, and privacy posture. Assign the lane that best fits each stage.
Run a verifier pass against the original goal and the evidence gathered. Verify the synthesis against the earlier plan and evidence.
Present the final output with receipts and open questions attached. Pause for human review before any important movement continues.
What stays visible
What stays visible
The plan
Show how the work was broken down before any worker step begins. Planner notes explain why the chain started the way it did.
The worker roles
Keep each scoped pass understandable so review does not depend on hidden orchestration. Worker records help users inspect what each stage actually handled.
The verifier pass
Show what was checked, what passed, and what still needs human judgment. Verification notes make quality checks visible.
The receipts
Keep evidence, assumptions, model lanes, decisions, and outputs connected to workspace history. Context history matters because orchestration is strongest when the user can see what the system carried forward.
How this fits in Ethen
Where it fits in Ethen
Ethen gives complex work an orchestration layer inside the model workspace. It connects naturally to Workflow for repeatable processes, Computer for visible computer-use steps, Gateway for routing, and Evidence for receipts. Cortex is the coordination layer for jobs that need more than one pass, more than one lane, or more than one review stage inside the same workspace.
Who it's for
Founders managing complex launches
Coordinate research, writing, proof checks, and approvals without losing the work trail. Strong for larger jobs that need planning before production.
Product teams
Turn large goals into structured work with visible planning and verification. Helpful when several subtasks should be divided across different roles.
Engineering teams
Organize planning, review, validation, and release work with receipts. A fit for work that needs checks before a final synthesis is trusted.
Research-heavy workflows
Keep evidence, synthesis, and final writing connected instead of scattered across chats. Useful when context from earlier stages should stay visible instead of vanishing.
Operations teams
Turn recurring work into visible orchestration before saving it as a workflow. Good for teams that want orchestration without pretending it is autonomous magic.
Model evaluators
Compare how different model lanes perform across planner, worker, and verifier roles. Helpful wherever approvals remain part of the path.
About Ethen
Make complex model work reviewable.
Try Ethen to plan, coordinate, verify, and keep receipts for the workflows that need more than one model response. Use it when the job is too important for one prompt and too complex for hidden chains.