Oxgate runs your agentic SDLC end to end: story to pull request, planning an epic or initiative, modernization and regulated change. Compose your own workflows and playbooks, run ours as they are, or start from them; the first release runs ours, and the other ways follow.
Each one is a playbook run from an item on your board, with people in the loop at the points your company chooses, because human in the loop is what makes automation like this succeed.
Label a story and the playbook refines it, agrees the technical approach, implements it, reviews the whole change and opens the pull request, then follows that pull request through: review comments answered, the branch kept mergeable and your CI's outcome recorded.
Label an epic and Oxgate checks that it says what it wants, proposes its stories in dependency order, and creates them on your board only after your product owner approves them, their points and the cost.
Label an initiative and Oxgate checks that it says what it wants, proposes its epics in order, and creates them on your board only after your product owner approves them, their sizes and the cost.
Oxgate takes stock of a repository, maps its domains and dependencies, recommends what to do with each part, and turns that into epics and stories your team picks and pushes to your tracker.
A regulated change carries its change record, a confirmed risk class, independent approvals, its change window and an evidence pack before its pull request opens, and its outcome is recorded after it merges.
Every process Oxgate runs is a playbook: ordered stages, each stage a versioned workflow.
The playbooks Oxgate ships: Story to PR takes a labeled story to a reviewed pull request and follows it to the merge, and the others plan epics and initiatives, review and test changes, reproduce bugs and plan a modernization.
Next
A copy of one of our playbooks, a stage of your own inserted and what each stage hands to the next read by the name its workflow declares; a copy of one of our workflows, its steps changed the same way.
Next
The designer: a palette of node kinds and connectors, validation on the server, a dry run, versions, and the triggers that start a workflow.
Questions, scope changes and approvals go to the owner, in the tracker or the chat your team already uses, and the run waits for the recorded answer.
When a story leaves something open, the question goes to the item's owner, the run waits, and it continues from the recorded answer.
A comment on a pull request Oxgate opened is answered on the thread or turned into a change that says what it changed; on a pull request somebody else opened, Oxgate reviews and never pushes.
Oxgate's chat commands are grouped by area in your communication tool, so somebody can find what to ask for without learning a syntax.
When the work turns out larger or different from the item, the scope change goes to the product owner and the decision is recorded.
A run that needs a person parks, names who it is waiting for and what it needs, and resumes on command.
A change arrives with what would otherwise be taken on trust: what was asked, what was tested, what was found, how long it took and what it cost.
Each acceptance criterion arrives marked met, partly met or declined, with the tests, the review findings, the wall time and the AI cost that produced it.
Oxgate watches your CI on the branches it owns and records what your pipeline concluded about the change.
Oxgate indexes the repositories you connect, so its work is grounded in your system rather than a guess about it.
Oxgate keeps a map of your system at several levels, from the code in each repository to the business domain it implements and the capabilities your business has, each tied to the code that delivers it, and updates it as the code changes.
Each repository you connect is indexed at one exact commit, so later work can find and cite the code it needs.
An approach is shaped from your repository, its conventions and the guidance your team keeps in it, and is posted to the item before anything is built.
The capability map names what the business is able to do in the words the people who run it use, and says which parts of the code deliver each capability.
What Oxgate may do is a document your CTO signs. What it did is a record your auditor can read.
A versioned policy document sets autonomy thresholds, the most a story may be projected to cost before Oxgate refuses to start it, how much work a team may have in flight at once, which tools a build may run, data boundaries that limit which repositories and knowledge sources Oxgate reads, and quiet hours that hold Oxgate's messages while work continues.
Roles and permissions decide who may approve, run and spend, and the published matrix is generated from the code that enforces it.
Every action is attributed to the person or the workflow that caused it and kept in an audit record your team can read and export.
AI usage and cost are recorded per run, per team and per company, so spend is visible while it happens rather than at the end of the month.
Your policy sets how many of Oxgate's pull requests may await review in one repository; at that number, the next story for the repository waits.
Work is sized against one published standard that names the risk the sizing carries, so an estimate means the same thing every time.
Your tracker, your source host, your chat, your identity provider and your AI provider, each connected under credentials you hold.
Your work tracker for work, your code host for code, your communication tool for conversation, and your identity provider for sign-in.
Oxgate runs on the provider and the model you choose, under a key you hold and can revoke, and the agreement with that provider stays yours.
You choose Anthropic, OpenAI, Amazon Bedrock or any OpenAI-compatible endpoint, and the guardrails apply on their own: an address of your own must be https on a public host and answer as an AI endpoint before it is saved, and Oxgate's own key is never sent to it.
Setting up a company asks only the questions its own answers make relevant, commits each section as it is filled in, and leaves every value editable in settings afterwards.
Written for the person who has to sign this off. Mechanisms, not adjectives, and the assurance we actually hold.
Oxgate has not yet been audited.
Each job runs in its own short-lived container, your code is cloned into it, and the container is destroyed when the job ends.
Builds and tests of that code run in a second, locked-down sandbox with no route to the internet and no credentials inside it.
Reasoning and code generation go through your own provider key, at the provider you choose. The index is kept with your company's data in Oxgate's database, and Oxgate trains no model on your content.
The index keeps excerpts of your code and documents and their vectors, the excerpts encrypted under your company's own key, and it is deleted with your company's data.
The working copy of your repository is destroyed with the job's container.
Each company's stored content is encrypted under that company's own key, with row-level isolation in the database and retention that deletes working data after a story ends while keeping the evidence.
Isolation is enforced by the database, not by application code remembering a filter, and each release is tested with two separate test tenants, each attempting to reach the other's rows. No customer data is used in testing.
Every action is attributed and audited, approvals and spend limits are policy, and nothing merges without your own review rules.
Request a pilot. A pilot runs against a staging copy or a fork with your own provider key, so no production access is needed to evaluate it.