Overview
What the Augeo Product Factory is, how tickets flow through plan, implement, and review, and how a new organization becomes a tenant.
Product Factory overview
The Product Factory (also called the Forge) is Augeo's agentic software delivery system. It turns work tracked in your existing tools — starting with Jira and Git — into planned changes, pull requests, and reviewed code, while humans keep accountability at the decisions that matter.
If your team is evaluating whether to adopt it, or to become a tenant alongside existing users, this guide is the shareable overview.
Lifecycle stages
Every change passes through seven stages. Agents execute between checkpoints; humans direct and remain accountable.
| Stage | What happens |
|---|---|
| Signal | Work enters the factory from an event — typically a Jira status change or label — or from another approved source. A human triages and prioritizes what should run. |
| Plan | A planning agent reads the ticket and the target repository, writes mission artifacts (spec, plan, work packages) to a spec/<ticket-key> branch, and leaves the plan for human approval. |
| Implement | After plan approval, an implement agent codes on a feature branch, runs repository quality checks, and opens a draft pull request. |
| Review | When automated review is enabled for a repository, pull-request events drive a review agent. A human still approves the merge. |
| Deploy | Merge and your existing CI/CD pipelines ship the change. The factory does not replace your deploy path; it hands off a reviewed PR. |
| Observe | Runtime and delivery telemetry feed back into the platform so outcomes are measurable. |
| Compound | After a ticket reaches done, a compound pass captures lessons so the next run is better than the last. |
Human accountability
Humans remain accountable at three checkpoints:
- Signal triage — decide what enters the factory and in what order.
- Plan approval — review the
spec/branch artifacts before coding starts. - Review approval — approve (or reject) the pull request before merge.
Between those checkpoints, agents run autonomously. Quality gates on the factory path currently run in advisory mode during adoption: findings are surfaced and measured, but they do not hard-block flow the way enforced gates will once criteria are stable.
How a ticket flows today
The day-to-day path is status-driven in Jira, with GitHub pull-request events covering review.
- Route the ticket. Set a Jira component that maps to a repository registered with the factory. The factory resolves that repository within the same organizational unit as the Jira connection that received the ticket. That is how it chooses which repo to plan and implement against.
- Start planning. Move the ticket to Ready for Spec. The planning
stage runs, writes mission artifacts to a
spec/<ticket-key>branch, and moves the ticket to Spec Created. - Approve the plan. A human reviews the spec branch. When ready, move the ticket to Ready for Agent.
- Implementation. The implement stage works on a feature branch, moves the ticket to In Progress once there are real changes, opens a draft pull request, and moves the ticket to Review.
- Automated review (optional). Opening or updating the pull request can drive the factory's review agent when that repository has review enabled. Merge remains a human decision.
(Label-based triggers exist as alternate entry points for the same stages;
the status path above is the primary operator flow. Ready for Development
also works in place of Ready for Agent to start implementation.)
The status names above are the factory's default routing statuses. Match them character for character — including board columns and fallback labels — by following Product Factory tenant setup. Different names will not route.
Multi-tenant model
The factory is multi-tenant:
- A tenant is an organization (for example, a business unit under Augeo).
- An organization has one or more organizational units. Configuration such as the Jira connection is scoped per organizational unit.
- Each Jira project key maps to exactly one connection. That is how inbound webhooks and outbound Jira API calls resolve which tenant's credentials and site to use.
- Registered repositories belong to an organizational unit. A Jira-triggered run uses a repository registered for that Jira connection's organizational unit. Repositories in your own GitHub organization are supported; the factory authenticates to whichever organization owns the registered repository.
This model was built so separate organizations can share the platform without sharing site URLs, tokens, or project mappings.
Becoming a tenant
A new tenant starts with two admin procedures you complete yourself, then a handoff to the Augeo AI Acceleration team for connection work only they can do.
Match the board and install Augeo Forge
A Jira administrator and a GitHub organization administrator can finish these without a meeting. Complete them before contacting Applied AI:
- Jira board — add the statuses the factory matches, map them onto the Applied AI columns, and confirm tickets stay visible. The factory keys off the ticket's project key, not the board.
- Augeo Forge — install the existing GitHub App on the organization that owns your repositories.
Follow Product Factory tenant setup for the exact status names, column map, fallback labels, install URL, and permissions.
What to send Applied AI
After the two procedures above, share the following so Applied AI can provision the connection:
- Atlassian site URL — the base URL of your Jira Cloud site (for example
https://your-org.atlassian.net). - Service-account email — a dedicated Jira user the factory will act as (transitions, comments, reads). Prefer a bot/service account, not a personal login.
- Jira project key(s) — the project(s) whose tickets should enter the factory. Each key maps to one connection.
- Repositories and components — for each repo the factory should work in, the Git host/slug and the Jira component name that routes tickets to that repo.
Applied AI provisions the Jira connection, inbound webhook, and repository registration. They will arrange a secure credential handoff for the service account. Do not send credentials over chat, email, or any other unsecured channel.
Automated pull-request review is optional and chosen per repository after the app is installed. The app install is required for every GitHub operation; review routing is a separate choice.
Who to contact
Reach out to the Augeo AI Acceleration team (the operators of the Product Factory). Confirm you completed Product Factory tenant setup, then share the intake items above.
Current state and limits
The Product Factory is in active development. It already runs the plan → implement → review path for onboarded projects, with compound learning after done.
Work in progress includes generalizing per-organization AI provider credentials and multi-Atlassian-site support so each tenant can bring its own model keys and Jira site without sharing platform defaults. A first engagement with a new organization is expected to start narrow — one Jira project, a small set of repos, and a pilot group of creators — then widen as the connection and workflows prove out.
The factory is meant to sit inside tools you already use, not replace them. If your organization builds its own AI-native development tooling, the goal is complementary capability and shared learning across Augeo — not duplicated effort.