CODENTO
Codento Engine
Agent-built software you can stand behind.
Born from 1.5 years of AI-assisted delivery for a global telecom leader, it now runs your Projects.
- Brief
- Plan
- Approve
- Build
- Deploy
- Prove
Why we built it
Built for our own delivery first
1.5 years of AI-assisted delivery on a SaaS platform for a global telecom leader taught us four things.
Speed
Code outran review.
Quality
Output varied with who prompted.
Governance
Who approved it? Which model?
Alignment
Every AI drifted its own way.
- One approval gate
- One quality floor
- One shared context
- One record
1,281changes mergedacross nine repositories in three weeks, built with the Engine. Today the Engine builds itself.
The shift
Code got cheap. Judgment didn't.
Agents collapse the build stage, so the work moves upstream to deciding what to build.
Before agents: every stage runs at human speed
- Plan
- Design
- Build
- Test
- Deploy
- Maintain
After agents: build runs at agent speed
- Plan
- Design
- Build
- Test
- Deploy
- Maintain
Cycle time reclaimed
Where the human work moves
Define the requirements
What should exist, for whom, and why, captured precisely enough for an agent to act on.
Shape the design
Architecture, boundaries and constraints: the decisions agents cannot make for you.
Facilitate the knowledge out
Interviews and briefings that get what is in people's heads into a form the Engine can use.
The bottleneck moves from writing code to defining the work (source: Anthropic). The Engine's briefing and planning exist for exactly this.
The gap
The person who knows the need can't build it
A business or product owner knows exactly what the application must do, yet every route to it today costs speed, control or quality.
Knows the what
- Knows the users, the process and the business outcome.
- Knows the rules the application must follow.
- Is not a software, security or cloud expert, and should not need to be.
Example: a partner onboarding portal with SSO, approvals and an audit trail, needed this quarter.
- Slow
Wait for the IT backlog
Built properly, but months in the queue. The need has moved on by the time it ships.
- Ungoverned
Low-code or shadow IT
Fast to start, but no security review, no audit trail and nobody to support it.
- Not enterprise-ready
AI prototyping tools
A demo in a day, without the auth, security, testing and operations an enterprise needs.
- Expensive
Outsource the build
Costly and slow to brief, and the knowledge leaves with the vendor.
Knowing what the business needs is not the same as building it to enterprise standards.
What the Engine solves
You own the what. The Engine owns the how.
You describe the need and make the decisions, while the Engine takes care of architecture, standards, quality gates and deployment.
- Describe the need
- Answer business questions
- Approve the plan
- Accept the outcome
Architecture
Settled from your code
Your standards
Applied in every Project
Quality gates
Tests and AI review
Deployment
To its own cloud project
Isolation
One Project, one perimeter
Access
SSO, scoped identities
Evidence
Every change recorded
Baseline
Quality floor, always on
Enterprise quality by construction: built to your standards, behind gates you approve, with every change on the record.
From idea to production
From idea to production with four human gates
Your people plan with their own method, the Engine builds, and four human gates decide what moves forward.
- Discover and define
- Architect and plan
- Approve the planG1 Owner approves the plan
- Build and verifyG2 Owner reviews output
- Review and mergeG3 Owner approves the deliveryG4 Your CI and reviewers
- Deploy and learn
Discover and define
- Your people
- The product owner frames the need.
- Codento Engine
- The briefing turns it into AI-assisted requirements and architecture in one isolated Project.
Architect and plan
- Your people
- Architecture, epics and stories take shape in your own method, for example BMAD.
- Codento Engine
- The Planner splits the plan into Tasks.
- Your tools
- Stories land in Jira or Linear; the brief and decision records are committed to GitHub, GitLab or Bitbucket.
Approve the plan
- Gate G1
- The owner approves the Epic plan in the Portal.
Build and verify
- Codento Engine
- Agents build, test and review in parallel.
- Your tools
- Backlog status is mirrored from the Engine.
- Gate G2
- The owner reviews agent output; developers can join from the IDE.
Review and merge
- Codento Engine
- The delivery is cut from the approved commit.
- Gate G3
- The owner approves the delivery.
- Gate G4
- The merge request goes through your CI and reviewers.
Deploy and learn
- Your people
- Decisions and learnings go back into the repository docs.
- Codento Engine
- Ledger keeps a record of every run, rule and cost.
- Your tools
- Your pipeline deploys and backlog items close.
Nothing reaches your source without G3 and G4. Your backlog and your Git stay the systems of record.
In the Portal
Brief, approve, watch, track
The Portal is where you brief the work, approve the plan, watch every agent and track every Project.
- Brief
Brief it like you would brief a colleague
- The Planner asks, you answer
- Guided steps: details, briefing, planning, review
- Upload your documents as sources
- Every answer lands in the Project's memory
The quality of this dialogue is the quality of the plan.
- Approve
Approve the plan before anything is built
- Epics wait for your yes
- Every Epic shows what it waits for
- Approved Epics run in parallel
- Drafts stay parked until you approve
The gate is real: agents cannot claim a Task whose Epic is not approved.
- Watch
Watch every agent at work
- Worker, verification and Reviewer per Task
- Every changed file, line by line
- Model and cost on every step
Evidence, not trust: the same record feeds the Ledger audit trail.
- Track
One view of every Project
- Status at a glance
- What needs your action now
- Runs in flight and Tasks done
- Engine, repository and setup health
Sign in with your company account; your role decides what you see.
The Engine
Five parts, one governed flow
Portal is the front door, and the other four parts run together per Project as one isolated instance per engagement.
- Enter
Portal
The customer workspace: sign-in and access, the Project directory and live monitoring of every run.
- Know
Project Context Hub
The Project's context and memory: briefing material, sources and Skills that everything else reads.
- Track
Flux
The work tracker: Epics, Tickets, dependencies and the approval gate, in sync with Jira and Linear.
- Plan and build
AOL
The planning and execution system: its Planner shapes the plan, and its agents build, verify and review the work through the gates.
- Prove
Ledger
The record of what each agent did, on which task, with which model.
Your standards travel as Skills. Organization capabilities are the organization-wide ones, shared once and applied in every Project.
Governance and provenance
Governance blocks. Provenance records.
Governance stops work that shouldn't ship, and Provenance records everything that does.
Governance blocks: work cannot pass a gate without a yes or a passing checkApprove
Human gate on the plan
Agents build
In parallel, red-green
Verify
The task's checks
AI review
A verdict on every change
Merge
Your review, your CI
Which agent, which model, which task, which instructions, what it cost. The task log and the git history give a timeline per Project.
Verification and review reduce uncertainty before a change ships; your review and your CI keep the final say.
Codento Baseline
The quality floor in every Project
The Codento Baseline is the minimum Codento delivers on every Project, and your Skills build on top of it, never below it.
Project Skills
Rules for this Project
Organization capabilities
Your org-wide standards
Codento Baseline
Quality and security checks and Codento engineering skills. Always on, never removed.
- Secret scanning
- Lint and types
- Code health
- Infra checks
- Tests first
- Verify gate
- AI Reviewer
- Human approval
Minimum, not maximum: the Baseline meets Codento's quality bar on every delivery, and your Skills raise it to yours.
Bring your method
Your method shapes the thinking. The Engine delivers.
Keep the planning method and the editor your teams already use, and let the Engine add the execution, gates and record.
Your engineers and architects decide
- Product brief and PRD
- Architecture and UX decisions as documents in the repository
- Epics and stories, agreed by people
Agents deliver behind enforced gates
- Turns approved plans into gated Tasks
- Agents build, test and review in parallel
- Human-approved merge requests, with a record of every run
- Available today
BMAD documents brief the Engine
PRD and architecture upload straight into the Portal briefing.
- Available today
BMAD skills run inside the Engine
Same skill format. They load as your Project Skills.
- Under evaluation
The Engine adopts BMAD practices
A faster path for small changes, in terms your teams already know.
Use the Engine from your own editor
Engine MCP lets the AI assistant in Cursor, Claude Code, Antigravity or VS Code work with your Project directly.
Add one server
Add the Engine MCP server with the Portal URL in your IDE's MCP settings.
Sign in once
Your normal Portal login in the browser. No API keys to copy.
Ask in plain language
The assistant picks the tools. You see and approve each call.
Same permissions
You only see the Projects and actions your Portal role allows.
Neither replaces the other. Your method keeps your people in the decisions; the Engine adds the execution, gates and audit trail.
Proven on our own work
Three days. A year of conventional work.
What the Engine shipped on 28–30 Aug while building itself, sized as a conventional project with the standard COCOMO models.
Calendar time for the same output
Basis: Basic COCOMO 73.1 · COCOMO II 105.3 person-months, 5.7–6.5 developers full time; the Engine build ran 28–30 Aug.
3days28–30 Aug, built with the Engine
- 73–105person-months of effortBasic COCOMO 73.1 · COCOMO II 105.3
- 13–16months of calendar timea year-plus schedule for a human team
- 6–7people on the team5.7–6.5 developers, full time
Roadmap
What comes next
What you get on your Project and how the Engine itself evolves, in order rather than dates.
Your Project
What the Engine does for the app you build
- NowOrganization capabilities shared across Projects: org-wide context, Skills, requirements and design system.
- NowDeploy the app into your own Google Cloud project.
- NextStronger agents: richer skills, sharper planning and review.
- NextAWS, Azure and Kubernetes on-prem as output targets, with development support.
- LaterCodento hosted service: Engine Hosted Apps for small sites, or a hosted Google Cloud project, Codento-provided or yours via Marketplace.
The Engine itself
How the Engine is run and secured
- NowThe Engine deployable into your own Google Cloud organization.
- NowHardening the self-serve Portal from first customer use.
- NextCloud Armor and Private Service Connect.
- NextYour own model subscription, bound per Project.
- LaterLocked agent network with a hosted web proxy.
- LaterManaged and shared image registries, security-scanned.
Customer-led: ideas move into the roadmap when a customer needs them, so tell us what yours are.
Get started
Run a Project on the Engine
Access is invite-only, and we set up your first Project with you in one session.
- Your own Project
- Isolated repositories, context, tasks and audit trail
- Your standards
- Org-wide context, Skills and requirements
- Your code
- In your repository or output repository, or as a ZIP
Sign in to Portal
Sign in with your company account. Portal shows your Organization and its Projects.
Create the Project
Guided setup: import repositories from GitHub, GitLab, Bitbucket or Gitea and size the agent VM. Quality gates are built in.
Run the briefing
A Scout reads your code, then the Planner asks its questions.
Approve the epics
Review the epics and tasks the Engine derived and approve the ones you want built. This is the go or no-go moment.
Watch, steer, accept
Follow progress live in Portal and accept the delivery against your business outcomes. Code review is optional.
Start with one Project.
Pick one real piece of work. We brief it with you, you approve the plan, and the Engine builds it. You keep every line of code and the record of how it was made.
Next step: a pilot Project, scoped together in one briefing session.
Start with one Project