Saved Successfully.

Coming soon

Catalyse

AI Coding From Your nucleus Backlog

Send a task from webcore nucleus to Catalyse and an AI coding workflow plans the change, waits for a person to approve the plan, then writes, tests and reviews the code and delivers it as a pull request in your own GitHub repository. The task stays the single record of what was asked, what was agreed and what was delivered.

The backlog already knows what to build

Why start the coding somewhere else?

A well-written task already holds the requirement, the acceptance criteria, the repository it belongs to and the people who need to agree to it. Yet most AI coding happens in a separate tool, on someone's laptop, with the context pasted in by hand and no record on the task of what the AI was asked to do or what it changed.

Catalyse starts from the task itself. The request is taken from the task, the plan is approved on the task, and the result comes back to the task, so the work is planned, reviewed and accounted for in the same place as everything else your team delivers.

Coming soon

Catalyse is coming soon to webcore nucleus. Register your interest and we will be in touch as it becomes available.

  • Send to Catalyse from any task
  • Plan before code
  • Human plan approval
  • Implement, fix and test
  • Separate code review
  • Pull request in your repository
  • Choice of AI models
  • Reusable instructions
  • Role-based access
  • Run history on the task

What it is

An AI coding workflow that answers to the task

Catalyse is the coding workflow inside webcore nucleus. A project is connected once to the GitHub repositories it works on. From then on, anyone with permission can open a task, check the instructions and select Send to Catalyse.

The workflow does the planning, coding, testing and review. Your team does the deciding: nothing is built until a person approves the plan, and nothing reaches your main branch until your team merges the pull request.

  • Starts from the task description and implementation instructions
  • Works only in the repositories the project has connected
  • A person approves the plan before any code is written
  • Delivers a pull request for your team to review and merge
  • Status and results are shown on the task, not in a separate tool

How it works

From task to pull request, with people in charge

Every run follows the same steps, and every step is visible on the task.

Send to Catalyse

One action on the task

Open the Catalyse tab on a task, check the title and instructions, and send it. The request is saved with the task at that moment, so later edits to the task never change a run that has already started.

The right repositories

Chosen per project, per task

Each project keeps its own list of GitHub repositories and defaults. A task picks from that list, and a repository Catalyse has not been granted access to is shown as unavailable rather than silently skipped.

Set up once

A short first-use wizard

Choose the repositories, the coding model and any reusable instructions the first time you use it. Every task after that opens straight on the task, with your saved choices ready.

Instructions that carry over

Your conventions, every time

Save reusable personal instructions, such as coding standards or how your team writes tests, and apply them to any task without retyping them.

A plan first

Read the code, then propose

Catalyse reads the repository with read-only tools and proposes a plan for the change: what it will touch, how, and how it will be tested. No code is written at this stage.

A person approves it

Approve, or ask for a new plan

A member of your team reads the plan and either approves it for implementation or adds guidance and asks for a revised plan. Coding starts only after that approval.

Your choice of model

From the models you enable

Choose the AI model for the run from the models enabled for your nucleus account. Usage runs on nucleus model credits, so there are no provider keys for your team to manage.

Fixed when the run starts

No surprises mid-run

The request, repositories and model a run starts with stay fixed for that run. Changing your settings affects the next run, never the one in progress.

Implement

Code that follows the approved plan

Catalyse makes the change in an isolated workspace, following the plan your team approved rather than improvising a new one.

Fix and test

Run the tests, correct, repeat

It runs your project's tests and corrects its own work when they fail, so the pull request your team receives has already been through the checks you rely on.

A separate code review

Fresh eyes on the change

The finished change is reviewed in a separate session, apart from the one that wrote it, so the review is not simply the author agreeing with itself.

Progress on the task

See where the run is

The task shows the run's current status, its latest activity and its results, so anyone following the work can see where it is without asking.

A pull request in your repository

Your GitHub, your process

The change arrives as a pull request in your own GitHub repository, linked from the task. Your team reviews it, asks for changes and merges it exactly as they would any other.

Ask for a revision

Describe what to change

If the pull request needs more work, describe the change you want from the task and Catalyse updates the same pull request.

Merging stays with you

Release through your normal process

Catalyse never merges or releases. What reaches your main branch, and when, is decided by your team and your existing release process.

A record on the task

What was asked and what was delivered

The saved request, the approved plan, the run's results and the pull request link all stay with the task, alongside its time, approvals and history.

Built for trust

The agent proposes. People decide.

Catalyse is designed so that an AI model never holds more authority than the task it was given. Access to your code is granted by your team, the plan is approved by your team, and the pull request is merged by your team.

  • Only roles you grant can use Catalyse, and only on projects they can access
  • Access is limited to the repositories your team connects
  • GitHub credentials stay with the platform and are never shown to the AI model
  • No code is written before a person approves the plan
  • Changes arrive as pull requests; Catalyse never merges
  • Every run is recorded against its task

Works with

Part of the Webcore product family

Catalyse is part of webcore nucleus, and takes work from across the Webcore products.

webcore nucleus

Catalyse lives on the nucleus task. Sprints, estimates, approvals and cost tracking all apply to the coding work just as they do to everything else.

Fusion Core - coming soon

When a Fusion Core diagnosis finds the cause in the code, it can propose a fix task in nucleus carrying the evidence, ready for your team to send to Catalyse.

Be first to see Catalyse

Catalyse is coming soon to webcore nucleus. Register your interest and tell us which part of your backlog you would hand to it first.