Build your own software factory. In minutes.
- Open source
- Not tied to one vendor
- Secure, sandboxed agents
Agentic SDLC runs a team of AI agents in your team's own process, on the services you already use, from idea to production and back. You decide what starts them, how far they go and where a person signs off, so your people can focus on what matters most.
Early access opens to a few teams at a time. We email you only about Agentic SDLC. Privacy
Start with one step.
Grow at your pace.
Agents work in the tools your team already uses, with the models and harness you choose. No vendor lock-in.
Join the waitlistWatch how it works 1:19
This is an example. Your workflow can look different: choose which steps agents take, start with one, and add more as your team is ready. See example workflows
- GitHub
- GitLab
- Jira Planned
- Claude Code
- Codex
- Anthropic
- OpenAI
- AWS
- Google Cloud
- Azure
Works where your team works
Writing code got easier.
Shipping it didn't.
AI made writing code fast. The rest of the loop still runs on people: they coordinate the agents, review what they made and find out whether it worked.
Every AI tool covers only one part
One tool writes the code, another reviews it, a third fixes the build. None of them plans the work, follows it to production or learns from what happens there.
People became the glue
People carry the work from one tool to the next, watch each session and review every change. They hold more context, switch more often and have less time to think. The pace went up, and so did the stress, and the work that keeps quality high is the first to go.
Every platform brings its own agents
Built-in agents work only on their own platform, with the models it picks and the price it sets, and no one wants a different agent platform for every team. Your services, your models and where your agents run should stay your choice.
For developers
Just drop
one file
Add .sdlc.yaml to a repository and its agents start working. It says what runs each agent, what starts it and what it does, in plain language.
- Start from a label, a comment, a board column, a failed build or a schedule.
- Add your own roles: triage, a security expert, a release notes writer.
- Keep your labels, columns, branch names and review rules.
- Each agent remembers its issue from the first plan to the merge.
agents:
planner:
harness: codex
model: gpt-6.1-sol
session: issue
icon: 🧭
triggers:
- {event: issues, action: labeled, label: ai-do}
instructions: |
Read the issue and the repository's AGENTS.md.
Post a plan on the issue with acceptance criteria and tests.
If critical details are missing, ask the requester first.Grow it into a factory,
one step at a time.
Tailored to your workflow, and as automatic as you want. Keep the process your team already has, and hand agents one step of it at a time. You decide where a person signs off, and your branch protection and required reviews hold for agents too. Make it strict, or lean and fast.
-
Step 1
Helper
A reviewer agent reads every pull request your people open, before a person does.
You write, approve and merge.
-
Step 2
Pair
Create a branch from an issue, and a developer agent opens a small pull request for the reviewer to check.
You pick the work and merge.
-
Step 3
Team
An agent writes the requirements, design and tasks. Agents build only from the spec you approved.
You approve each stage and merge.
-
Step 4
Factory
Agents plan, build, review and merge, moving each card across your board from Backlog to Done.
You set priorities and answer what's assigned to you.
Each step is a few more lines in the same file. None of these fit? Build your own workflow, with any roles you can describe, from triage to release notes.
Beyond the pull request
Code is only half the loop. Agents also start from what happens around it: a ticket that moves, a review comment, a failed build, a schedule. They fix what broke and report back where your team will see it.
- Tickets
- A label, an assignee, a comment or a board column.
- Code
- A pull request opened, a review, or a push to a branch.
- CI/CD
- A failed build or pipeline. An agent fixes it, including on its own commits.
- Schedule
- Every few hours or on a cron schedule, for chores no event announces.
- Production Planned
- An alert from your monitoring opens or updates an issue, and agents take it from there.
For platform teams
One platform.
Every team's own workflow.
Your platform team installs it once and sets the limits every team shares, such as which hosts agents can reach. Within them, each team builds its own agents and workflow. Every layer stays yours to choose: the services your teams work in, the models your agents use, and where they run.
Orchestration
Agentic SDLC
- Agents
- Triggers
- Sessions
- Context
- Harnesses
- Sandboxes
You define the agents, what starts them and where a person signs off.
Control plane
Your services
- Issue tracking
- Version control
- Code review
- CI/CD workflows
- Monitoring Coming soon
Agents work in the services your team already uses.
Inference
Your models
- Anthropic
- OpenAI
- Google Gemini Coming soon
- Mistral AI Coming soon
- OpenRouter Coming soon
- Ollama Coming soon
- Your own hosting
You pick the model for each agent and can use your own keys.
Foundation
Your cloud
Kubernetes
- AWS
- Google Cloud
- Azure
- UpCloud
- Private
It runs in your cluster, on any cloud or your own servers.
Secure by default
Least privilege from the first run.
Every agent in its own sandbox
Each agent session runs isolated in a sandbox in your cluster, apart from your developers' machines and from other agents.
Zero access to start
An agent starts with no network, not even the internet. You allow exactly what it can reach, host by host.
Keys stay out of reach
Agents never hold API keys or tokens, so a prompt injection has nothing to steal or misuse.
Only trusted people direct agents
Only people with write access can start an agent. An outsider's issue or comment never triggers one.
Always in your sight
Governance you can follow.
Permissions you already control
Agents act through the permissions you set in your services. Branch protection and required reviews limit them like any team member.
Every session on the record
Follow an agent as it works, or review its session afterwards. Its actions show as comments, labels and commits in your services.
Approval where it matters
You decide which steps run on their own and where a person signs off. Nothing merges past your rules.
Costs in control
Guardrails on spend.
The right model for each job
A small, fast model for triage, a strong one for writing code. You pay only where it matters.
Scales with demand
Each task gets its own agent session, ready in milliseconds. Idle sessions are suspended, so nothing waits on your bill.
Guardrails against runaway agents
A loop limit caps how often a session runs each hour, so agents can't keep triggering each other.
Questions teams ask first
Something we didn't answer? Ask the founders.
How is this different from a coding assistant?
A coding assistant speeds up one person writing code in an editor. Agentic SDLC runs the team process around the code: planning, pull requests, reviews, build fixes and merging. Inside, each agent uses a coding agent such as Claude Code or Codex.
How is this different from the agents built into GitLab or GitHub?
Built-in agents work only on their own platform, with the models it offers. Agentic SDLC works with more than one provider, runs in your own cluster with your own model keys, and lets you choose the harness and model for each agent. It runs a team of agents that hand work to each other, from plan to merge, under the rules in one file.
Do we have to go fully autonomous?
No. Many teams start with a planner or a reviewer and keep merging themselves. You choose which steps agents take and where a person signs off, per repository, and change it whenever you like.
Where does our code go?
Agents run in sandboxes in your own cluster and read the repository through your code host. Code reaches the model provider you configure, with your API key, as it does with any coding agent.
Whose identity do agents act as?
Their own, never a person's. Agents act through your GitHub App or GitLab bot user, with only the permissions you give it, and every action shows under that name. An agent never borrows a developer's account or token.
Can every team set up its own agents?
Yes. Each repository has its own .sdlc.yaml, so every team chooses its agents, what starts them and where a person signs off. The platform team installs Agentic SDLC once and sets the limits all teams share, such as which hosts agents can reach.
What do we need to run it?
A Kubernetes cluster, access to your GitHub or GitLab, and an account with an LLM provider such as Anthropic or OpenAI. Your platform team installs it once; then developers add a .sdlc.yaml to their repositories.
Is it ready for production?
It is early. It works with GitHub and GitLab today, and Jira is planned. Agents already help build Agentic SDLC itself. We are starting with a few pilot teams.
*Is it open source?
Not yet. We plan to release Agentic SDLC as open source, and people on the waitlist hear first when the code is public.
What happens after I join the waitlist?
We open access to a few teams at a time, starting with pilot teams who help shape the product. Tell us about your team after you join, and we'll reach out when there is a spot for you.
Start with one boring task.
Pick the small job your team repeats every week and nobody wants: fixing flaky tests, updating dependencies, triaging new issues. Hand it to an agent with one file. Add the next task when you trust the first.
Or talk to the foundersEarly access opens to a few teams at a time. We email you only about Agentic SDLC. Privacy