Autonomous AI agent,
with governance and a human at the gate.
Guardi runs a fleet of coding agents through your SDLC — product planning to deploy — and pauses at the stages that matter for your approval. Agents handle everything. You review completed work.
Workflows
One standard template, fully yours to customize.
Define an ordered sequence of stages once — each backed by a typed co-agent or an outbound HTTP call — and every run advances automatically until it reaches a gate you locked.
Product Planning
Technical PM agent
Turns a one-line request into a detailed PRD before anything gets built.
Tech Plan
Tech lead agent
Designs the implementation approach and writes the technical plan doc.
Task Breakdown
Planning agent
Splits the tech plan into ordered, assignable units of work.
Development
Engineer agent
Implements the task against the codebase inside an isolated sandbox session.
Code Review
Reviewer agent
Runs a quality and security pass, flags issues before merge.
Deploy
HTTP stage
Calls out to your CI/CD or deploy platform to ship the change.
This six-stage flow is the standard given by platform, not a rule. user can combined with user need Reorder stages, drop the ones you don't need, swap a co-agent for a plain HTTP call, or add your own — then lock approval gates wherever your team wants a human in the loop.
Approval gates
An inbox for the decisions that actually need you.
Every gated stage lands in one inbox with the full output attached — docs, diffs, job logs. You decide what happens next; the workflow does the rest.
Approve
Stage 2 starts automatically. No re-triggering, no context to re-paste.
Retry
The same stage re-runs with your note appended as feedback context.
Abort
The entire workflow run stops. Nothing downstream executes.
Feature development SDLC — Stage 1 of 6
What happens next
- If you approve: stage 2 starts automatically.
- If you retry: this stage re-runs with your feedback.
- If you abort: the entire workflow stops.
Try it — click Approve, Retry, or Abort.
Autonomous team
A roster of typed agents, not one generic bot.
Co-agents are named, specialized profiles — bound to a CLI backend, a skill set, and standing instructions — assigned to whichever stage fits their role. Deploy one the way you'd bring on an engineer: hand it a task, and it runs the job end to end inside its own sandbox session.
golang-product-dev
Backend implementation
golang-tech-lead
Technical planning
technical-product
Product & PRD writing
frontend-dev
UI implementation
Engineer agent
General engineering
Data agent
Data & analysis
Every job runs sandboxed
Each agent executes in its own isolated session — its own shell, its own workspace — so one job's blast radius never reaches another.
Choose how much rope to give the team.
Team autonomy is a dial, not a switch — set it per project as trust builds.
Guided
Every stage pauses for your sign-off before it continues.
Balanced
Low-risk stages auto-advance; sensitive stages still gate on approval.
Autonomous
Agents handle everything. You review completed work.
Project memory
Context that compounds instead of resetting every run.
Every stage job shares one project_id, so agents read and write to the same episodic log, decisions, issues, and knowledge graph — no manual context passing between stages.
Episodic Log
A running record of what every agent read, decided, and changed — searchable by task.
Decisions
Architectural and product calls, captured where they were made instead of lost in chat history.
Issues
Bugs and follow-ups the agent surfaced mid-task, tracked without leaving the workflow.
Knowledge Graph
Patterns, decisions, and episodes linked into one graph per project — context that compounds run over run.
Code & security scans
Every repo gets scanned before it ships.
Rule-based scans run against your policy language and surface findings with a severity, the exact line, and a concrete suggestion — feeding straight back into the review stage.
internal/config/config.go:150
panic() in library code causes uncontrolled crashes.
cmd/server/main.go:105
Goroutine started without a WaitGroup or channel can leak.
internal/api/middleware/rate_limit.go:36
Hardcoded sleep durations signal polling-based sync.
Sandboxed execution
Every agent runs in its own secured pod.
Each session is scheduled into an isolated sandbox pod with its own filesystem, scoped credentials, and locked-down network. Agents never share a workspace — they hand off work and context through the orchestrator's message bus.
Pod-per-session
Every job gets a fresh sandbox pod, torn down when the run completes.
Scoped credentials
Secrets are injected per pod and never cross a sandbox boundary.
Locked-down egress
A pod reaches only the endpoints its co-agent profile allows.
Bus-mediated handoffs
Agents exchange work through the orchestrator — never pod to pod directly.
FAQ
How the pipeline actually behaves.
Bring your team into Guardi.
Define a workflow, assign co-agents to each stage, and lock the gates that need your sign-off. The CLI, API, and dashboard stay in sync automatically.