Task preparation UI
Normal keyboard shortcut, goal entry and sensitivity selection
Task preparation observed in the local browser
Back to selected work
Command Fabric
Prepare agent work with clear boundaries
Exploratory product development · Prototype
Command Fabric is an exploratory prototype for planning and bounding agent work: it turns a goal into a proposed route, roles, review steps and evidence requirements before execution.
Where it stands
- Demonstrated locally
- Task preparation with rule-based routing is shown in the local prototype.
- Still in development
- Execution, review and repair checks use simulated connections. No executor or model is connected in the recorded view.
Make the task legible before work starts
Command Fabric is an exploration of the work around an agent: defining the request, deciding which tools and roles fit, setting review points, and keeping evidence of what happened. Its task form turns a goal and sensitivity choice into a proposed route and work packet.
Deciding what agents may do
I use the prototype to explore what software may decide on its own, what a reviewer needs to see and when work should stop. I design the workflow and review points, then build and examine them with AI coding tools.
Walk through the prototype
Inspect the task-preparation screen. This recorded view shows planning before execution.
Recorded development screens · demonstration data
Prepare the work
A proposed work route makes roles, review steps and evidence requirements visible before execution.
Screenshots show the development build using demonstration data.
Further product and technical detail
The prototype also includes paths for execution, review, approval, correction and evaluation. The route shown in the preview follows fixed rules; model and agent connections are separate.
A rules-based preparation flow
In the example, a sample invoice-review request produces an accounting route, proposed roles and approval conditions before work starts. The user can inspect why the route was chosen and where it must stop for a decision.
I have also explored local inference and evaluation. Saved decoding-depth experiment records provide a separate example of examining local execution; they are distinct from the task-preparation screen and from model fine-tuning.
Task and sensitivity
A person describes the goal and relevant boundaries
Proposed route
Deterministic classification and routing
Roles and review plan
Executor, reviewer, stop conditions and evidence
Controlled run paths
Approval, execution, review and repair handling
Applications and roles
Execution and review controls
Approval, output boundaries, reviewer decisions and repair paths
Implemented in the prototype
Local inference exploration
Separate earlier decoding-depth and evaluation work
Earlier exploration; no new run or model training claimed
How it runs
| Mode | Current status |
|---|---|
| Captured example | Task packet prepared in the local browser |
| Task routing | Deterministic rules; not an LLM decision |
| Controlled runtime paths | Implemented and checked with simulated connections |
| Local inference experiments | Prior experiments kept distinct from fine-tuning and current task capture |
Technical detail
Saved local-inference records were not rerun; no new training result or model-quality comparison is claimed.
Employment contact · Oslo, Norway
Discuss a role
For a conversation about a relevant role, contact me by email or LinkedIn.