Private work deserves a private lane.
Use local and open-weight model workflows for sensitive context, private review, experimentation, and cost-aware iteration. Keep the work close to the workspace, with runtime visibility and human review built into the path. That can include sensitive drafts, repository review, internal notes, and open-weight experimentation when the runtime is configured to support it. Ethen Local keeps the boundaries understandable: what stays on the machine, what moves through the broader workspace, and what still needs a human decision before it should travel further.
A private lane for model work that should stay closer to the machine.
Ethen Local gives sensitive code, internal notes, private drafts, and open-weight experiments a dedicated lane inside the broader model workspace. It makes local work part of the same operating flow instead of a disconnected side tool, while avoiding promises the runtime or machine configuration has not earned.
Why it exists
The best model path is sometimes the closest one.
Local and open-weight models give builders more control. Ethen Local keeps that work connected to the same workspace, evidence, and approvals. Some work deserves a private lane because the context is sensitive, the task is exploratory, or the builder simply wants more direct control over where the model runs. Ethen Local gives that work a place inside the same workspace without pretending every feature behaves the same in every environment.
- Use local lanes where supported for sensitive context. The page should help users decide whether local work is the right fit before they start.
- Experiment with open-weight models inside Ethen. Control matters when private context and experimentation meet.
- Compare hosted, open, and local behavior. Evidence and approvals still matter even when the lane is local.
- Keep runtime state and review notes visible. Runtime setup, model availability, and machine capability remain real boundaries.
What you can do
What could you keep in a private lane?
Use Ethen Local when context matters and exposure should be deliberate. The goal is not to treat local models as magic. The goal is to explain when a local lane is useful, what it can keep closer to the machine, and what still depends on runtime support and user review.
Review sensitive code
Prompt
Review this unreleased code path using a local lane where available.
Result
A private review pass with inspectable notes. The result should explain what context can stay closer to the machine and what the user should still verify.
Test open weights
Prompt
Compare how this open-weight model handles summaries and extraction tasks.
Result
A structured comparison of strengths, gaps, and prompt behavior. A good answer should separate privacy posture from unsupported promises about total isolation.
Draft internal notes
Prompt
Rewrite these internal planning notes in a private lane.
Result
A cleaner internal brief with review state visible. The workflow should make runtime and model availability visible instead of assumed.
Compare lanes
Prompt
Run this task through flagship, open, and local lanes.
Result
A lane comparison for quality, speed posture, and review needs. The review should note where a stronger cloud model might still be the better fit.
Example workspace
A sensitive review stays close to home.
Scenario
A founder reviews unreleased strategy notes and code comments with a more controlled model path. They want a quieter review path before anything is shared more broadly.
Local workspace · private review
Use a local lane where available to review these notes and flag what needs approval. Call out runtime assumptions, what context stays local where supported, and what still needs approval before it leaves that lane.
Execution steps
- 1Opens work inside a private lane. So the user knows what material is in scope.
- 2Identifies the context type. The runtime should be visible enough that the lane feels real, not implied.
- 3Runs a local or open-weight workflow where supported. A local path is chosen intentionally, not as a slogan.
- 4Returns review notes and uncertainties. The review should show whether a broader model lane is still needed.
- 5Keeps lane choice and history visible. That keeps privacy posture tied to observed behavior instead of vague claims.
Core Workflows
Core local workflows
Ethen Local is built around context control, model choice, runtime visibility, and review. It turns local work into a first-class option for the jobs that benefit from it, while keeping expectations grounded in actual runtime behavior.
Sensitive context review
Use a private lane for code, internal strategy, notes, or drafts. That matters when code, notes, or drafts are still taking shape.
Open-weight experimentation
Test open-weight models on realistic tasks. Runtime awareness helps the user see what is actually available.
Local runtime visibility
Show selected lane, prompts, outputs, and runtime context. Open-weight experimentation belongs in a lane that can be inspected and repeated.
Cost-aware iteration
Use local and open lanes for repeated drafting or review loops. Private review is most credible when the path is visible and the boundaries are named.
Private draft workflows
Draft internal docs, planning notes, and decision briefs with closer control. The workspace should still record what happened and what the user decided next.
Lane comparison
Compare local, flagship, and open lanes for the same task. Cloud and local work can live together, but they should not be confused.
Model Lanes
Use the right model lane
Local is one lane inside the larger workspace. Use it when context sensitivity, control, or experimentation matters. Local is not a replacement for every other lane. It is the lane for the moments when control, proximity, or experimentation matter most.
Flagship models
Use for complex reasoning, architecture, planning, synthesis, and review where judgment matters most. Useful when the task still benefits from top-tier reasoning outside the local path.
Open models
Use for fast iteration, drafting, extraction, transformation, and cost-aware repeated work. Helpful for lower-cost support work that does not need the strongest lane every time.
Local models
Use for sensitive context, private review, and controlled experimentation where local lanes are supported. Best when the runtime is configured, the machine is ready, and the user wants closer control over sensitive context.
Where it works
Where Ethen Local fits
Use Ethen Local when the question is not only which model is best, but where the context should go. It fits when privacy posture, cost awareness, or hands-on experimentation matters enough to influence model choice.
Private code and product work
Review unreleased code and plans in local lanes where supported. Private note review is a common first use because the boundaries are easier to understand.
Research and drafting
Work through private notes before moving outputs wider. Code review can benefit when exposure should remain deliberate.
Model experimentation
Test open-weight models against real tasks. Open-weight experimentation belongs in a workspace that can keep notes and results together.
Gateway-connected products
Make local lanes part of the same routing story as hosted lanes. Hybrid work matters because local and cloud lanes often complement each other.
Workflow
A private lane workflow
Start with context sensitivity, then choose the model lane. Choose the local lane because it fits the work, not because the label sounds safer.
Classify the context. Start by naming why the work deserves a local pass.
Choose local or open lanes where useful. Check runtime support and the user’s machine boundaries.
Run the review or draft workflow. Bring only the context that should enter the lane.
Capture output, assumptions, and approval needs. Review the result before sharing, exporting, or escalating it.
Promote approved results into the broader workspace. Keep the decision record in the workspace.
What stays visible
What stays visible
Model lane
Show which flagship, open, or local lane handled the work. Visible context helps the user decide whether the lane was appropriate.
Evidence
Keep receipts, assumptions, and review notes attached to the output. Runtime visibility keeps local work grounded in what the machine can actually do.
Approvals
Pause sensitive or state-changing steps for explicit human approval. Lane records matter because privacy posture should be reviewable.
Workspace history
Preserve the work so it can be reviewed, reused, and improved. Approvals still belong in the story when sensitive material may move onward.
How this fits in Ethen
Where it fits in Ethen
Ethen Local is the private lane inside the model workspace. It gives the broader model workspace a private lane without turning privacy into a slogan or pretending every setup behaves the same way.
Who it's for
Privacy-sensitive builders
Use a lane designed for closer context control. Especially useful for drafts or notes that should stay closer to the machine.
Developers
Review private code in local lanes where supported. A fit for teams exploring open-weight models without leaving the workspace behind.
Open model experimenters
Compare open-weight behavior inside Ethen. Helpful when private code review should happen in a more controlled lane.
Cost-aware teams
Use local and open lanes for repeated work. Good for cost-aware experimentation before a stronger cloud model is needed.
Researchers and writers
Draft private notes before sharing selected outputs. Strong for builders who want local work to remain connected to approvals and evidence.
About Local
Give private work a model lane of its own.
Try Ethen to explore local and open-weight model workflows for sensitive context, private review, and controlled experimentation. Use it when closer runtime control matters as much as the answer itself.