Agentic work in a controlled loop

Turn your backlog into a running delivery loop.

Gridly routes backlog work from GitLab into versioned process definitions and worker environments. Agents can do the toil; developers keep the specs, review, and delivery value under control.

Start NOW! Documentation See the loop

Your team knows the work. Gridly gives it a safe lane.

Use it for toil, tech debt, tests, integrations, migrations, reviews of stale code, or any backlog item that has a clear spec and a repeatable process.

POs write intent

GitLab Issues hold the task, acceptance criteria, discussion, and final status.

Developers define process

Gridly YAML describes which agentic work can run and under what conditions.

Agents do the toil

Workers run OpenCode jobs while people keep review, merge, and product judgement.

The loop is spec-driven work mapped to real execution.

GitLab describes what should happen. Gridly master YAML describes the process. Worker YAML describes where it can run. OpenCode executes and writes the result back.

Gridly loop logo
Controlled agentic deliveryGridly keeps process and state around the worker run.
1

GitLab specs and tasks

Issues carry the work description, acceptance notes, labels, comments, and human decisions.

2

Gridly master YAML

The server config maps labels to job profiles: image, model, prompt, match rules, timeout.

3

Gridly worker YAML

The worker config defines runtime, workspace, network ports, labels, and available capacity.

4

OpenCode run and review

The worker runs the job, streams logs, returns a result, and GitLab remains the review surface.

The agent does bounded work. Gridly records state. Humans decide what ships.

Gridly crew coordinating a maintenance program
Case study

Do the work nobody has time for.

Every team has important work that customers do not see directly: dependency updates, security checks, docs, test coverage, refactoring, and cleanup. Product teams know it matters, but roadmap work usually wins.

1. Collect the toilWe moved this work into GitLab Issues with clear labels and simple acceptance notes.
2. Let Gridly route itGridly matched those labels to versioned YAML workflows and started processing the queue.
3. Use idle capacityOld hardware runs dev containers with OpenCode workers, orchestrated by Gridly.
4. Spend unused tokensOutside working hours, unused tokens turn into maintenance work that nobody had time to do.
Run it

Start with one project and one worker.

Use placeholders here only. Store real tokens in your shell, secret store, or ignored local config. Never commit them.

Open GitLab 
git clone https://gitlab.com/openforge/gridly-scheduler.git
cd gridly-scheduler
go build -o bin/gridly ./cmd/gridly

export GITLAB_TOKEN="glpat-your-token"
export GRIDLY_WORKER_JOIN_TOKEN="replace-with-worker-join-token"

./bin/gridly serve -c gridly-server.yaml
./bin/gridly worker run --daemon -c gridly-worker.yaml

Real secrets belong outside Git and outside screenshots.