Work with clear limits
Choose the work worth doing, the tools an agent may use and the conditions that should stop a run.
Coding workflows / Native Hew
From approved issue to reviewed change.
Hewbers is an open-source coding-workflow runner written in Hew. Original Goobers workflows run natively in selected local profiles: implementation produces a reviewed PR; separate merge review checks eligible PRs, merges the exact approved head and closes linked issues. Reuse trusted verdicts without skipping current checks. An explicit comment-watch task can route fresh human feedback into remediation on the same PR.
HewbersOpen source
Built in Hew.Goobers workflows
Hew implementation
01 / The workflow
Turn approved work into reviewed code.
The unchanged Goobers starter, implementation and merge-review workflows run through the normal serve, start, status and trace commands. Each scheduled workflow runs in its own selected local profile; the init starter stays manual-only. Implementation leaves the issue open and in review. The separate merge-review workflow can then merge an eligible PR after fresh approval, head, base and CI checks.
The issue-to-change workflow
Running locally- 01
Choose ready work
Claim an approved, ready issue and gather the context for the configured implementer.
- 02
Make and review
The implementer changes the code. An independent reviewer checks that exact revision.
- 03
Publish and check
Push the reviewed head, run the original local CI and open or update the pull request.
- 04
Repair when needed
Check provider CI. Review or CI failures send the work through another pass on the same PR.
- 05
Hand off for merge
Finish the run and release its claim. Leave the issue open and in review; merging is separate.
Review and CI failures now exercise real repair passes. If the base branch advances, merge it, independently review the new head, push it and run local checks again.
Keep review independent
Writing the change and deciding whether it is ready are separate responsibilities.
Keep your repository's rules
Existing checks and approval policy belong in the workflow. Automation should work within them.
02 / Why Hew?
A substantial application for a new language.
Hewbers is one of Hew's first substantial open-source applications. It gives the language a practical job: coordinating coding work across processes, repositories and failures.
Hew is an actor-oriented language for concurrent and distributed systems. Hewbers takes those ideas beyond small examples. Run ownership, message passing and recovery have to fit together in a program that does useful work.
Meet the Hew language ↗Concurrency with clear ownership
Several runs may be active at once, but two runs must not silently own the same task. Actors give the design a place to keep each run's state and decisions.
Recovery after interruption
Processes stop. Machines restart. A provider can time out after accepting a request. The runner needs to remember what happened before it decides what to repeat.
Real tools, real boundaries
An agent launches processes, reads files and talks to a repository host. Runner policy and private working data must remain meaningful at those boundaries.
Review that follows the code
Approval of one revision must not become approval of the next. Implementation, review and checks need to stay attached to the change they actually cover.
Inside the runner / Native local workflows
From admitted task to recorded result.
Native services now carry the original authored workflows from admission to completion and claim release. Status and trace expose the recorded work, including after restart. Resource-aware kits and bounded local parallel graphs remain separate options: they cannot be combined.
Normal service entry
Run owner
Check optional configured requirements before provider or task activity. Choose one runner for every task and pin the original workflow, policy and full inventory.
Requirements → runner → pinned run
Results and gate decisions
Durable state
The owner checks results, artifacts and gates before completion and claim release. Run views and exports retain the checked input evidence. Completed runs retain their original result without launching work again.
Checked result + gate → owner completion
Separate local profiles
Execute and join
Sequential kits deliver the original workflow, policy and checked inputs. Parallel graphs use distinct committed workspaces and join only when every branch succeeds. Kits and graphs cannot be combined.
Read-only branches → all succeed → join
Remote sourceThe trusted scratch-worker source connects delivery → authenticated start → bounded result → independently checked completion and release. Its native role builds, but the remote path stays off by default. Full worker-chain, image and Kubernetes operation still need separate runs.
Goobers is the starting point: a self-hosted platform for coding workflows with defined roles, controlled execution and human handoffs. Hewbers is a parity implementation in progress, written in Hew rather than a wrapper around Go.
The original starter, implementation and merge-review workflows now run unchanged in selected local profiles. Implementation hands its PR to a separate review and merge process rather than merging as a side effect of success. Overlapping managed PRs follow controller-selected FIFO order: nonwinners wait on predecessors, and resolved blockers can release the wait. Independent review still decides whether the code has substantive defects. These controlled local paths are concrete steps towards Goobers parity, not the whole product: broader workflow branches, live services and installed operation remain ahead.
How the projects fit together →04 / The road ahead
From working workflows to an operated service.
Original implementation and merge review now run in separate selected local profiles. Broaden live-service coverage, complete the remaining workflow branches and remote execution, and prove installed operation. Goobers parity remains the goal.
These are project outcomes, not release dates.
Explore the features →-
Running locally
Run the authored local workflows
Run original authored workflows through the normal service, with recorded results and claim release.
-
Local suites passing
Keep workflow upgrades explicit
Review and publish one supported version change without overwriting an original or rewriting a live run.
-
Running locally
From original workflow to reviewed PR
Run the original implementation on its twice-daily schedule, taking approved work to a pull request for separate merge review.
-
Running locally
Close reviewed PRs and linked issues
Run the original hourly merge-review workflow from PR selection through independent review, exact-head merge and linked-issue closeout.
-
Running locally
Give overlapping PRs an order
Elect eligible managed PRs in FIFO order, park nonwinners on predecessors and unpark them when blockers resolve.
-
Running locally
Finish queued and obsolete PRs
Follow queued merges to closeout and close objectively moot, duplicate or superseded PRs after independent non-passing review.
-
Running locally
Respect scope and retain repair work
Review scope-gated PRs, reconcile acknowledgements and heal existing remediation records against current code and target branches.
-
Running locally
Reuse reviews and classify Tutor changes
Reuse trusted verdicts with fresh current-run checks, recover stale comments and apply Tutor policy at selection, direct merge and queue admission. Cache sibling file paths and line totals without skipping live PR metadata.
-
Worker builds
Run the remote scratch-worker cycle
Deliver a trusted task to a worker and return a result the owner can safely accept.
-
Operating checks ahead
Ship a service people can operate
Install, start, inspect, restart, upgrade and restore Hewbers without a developer checkout.
-
Running locally
Author tasks with agents and reviewers
Choose agents and reviewers in an authored workflow, with decisions tied to the work they actually reviewed.
-
Planned after authored agents
Approve, override or rerun a stage
Make a deliberate human decision that the run owner records and carries out once, even across a restart.
-
Routing runs locally; repair planned
Turn human feedback into a reviewed PR update
Route fresh human comments into remediation; next, carry them through repair and review on the same branch and confirm the exact published change.
-
Further work
Cover the wider Goobers workflows
Support the resources, access and execution profiles that complete coding workflows need.
05 / Explore the projects
Explore Hew and Goobers.
Workflow design, actor systems, independent review and recovery all meet here. Hewbers is a practical reason to explore both the language and the project that inspired it.