Your internal tools don't need more engineers. They need a product owner.
Steward is an AI system that autonomously owns the software your team has built but nobody has time to manage. It watches your repos, triages issues, fixes bugs, deliberates features with AI debate teams, and brings only the important decisions to your approval queue.
Building internal tools has never been easier. Managing them has never been harder.
Claude Code, Cursor, v0, and a dozen other AI tools have made it trivially easy to build and deploy internal software. That's a good thing — until you have 30 of them and no product owner for any of them.
Every one of those tools starts dying the moment its builder moves on to the next project. Issues pile up untriaged. Bugs ship without QA. Features creep without anyone asking "should we?" Nobody writes changelogs. Nobody holds the vision.
This isn't an engineering problem. It's a product management problem. These tools don't rot because nobody can fix bugs. They rot because nobody is asking "what should this product become?" and "does this change serve the user?"
You can't hire a product manager for each internal tool. But you can't afford to let them rot either. That's the gap.
60–90%
of a software product's total lifecycle cost is spent on maintenance — not building it in the first place.
0
internal tools at a typical enterprise have a dedicated product owner. The builder is the PM, the QA team, and the support line — until they're not.
3–6 mo
average time before an internal tool with no owner begins accumulating critical unresolved issues.
The insight
Product management exists for a reason.
Every successful product has someone who holds the vision, prioritizes ruthlessly, says no, translates intent into scope, and communicates what shipped. Steward provides that discipline — autonomously.
🧭
Holds the vision
Steward reads and scores your VISION.md — the document that defines what this product is, who it serves, and what it is not. Every decision is evaluated against it.
⚖️
Prioritizes ruthlessly
Classifies every incoming issue by type and impact. Bugs get fixed. Enhancements get evaluated. Features get deliberated. Nothing sits untriaged.
🛡️
Says no
A skeptic agent challenges every proposed change. If it conflicts with the vision or introduces unnecessary risk, Steward flags it — or rejects it outright.
📐
Translates intent into scope
For approved work, Steward produces engineering analysis: what changes, what's affected, estimated effort. The "what" is defined; engineering handles the "how."
📣
Communicates what shipped
Auto-generated changelogs in product language, not commit messages. Your stakeholders know what changed and why — without you writing a word.
"For your flagship product, you have a PM. For your 15 internal tools — you don't. And you can't hire 15 PMs."
Strong product management represents the business in what gets built and in what order. PMs own the "what" to sufficient detail that engineering can own the "how."
Without that discipline, products drift. Features get added that serve nobody's strategy. Bugs linger because nobody is prioritizing. The tool quietly becomes a liability instead of an asset.
Steward doesn't replace a PM on your core product. It provides PM discipline for every product that doesn't warrant a dedicated human — but still deserves one.
How it works
Three steps. Five minutes. Product ownership.
Point Steward at a repo. It reads your vision doc, understands your autonomy boundaries, and begins watching.
01
Point it at a repo
Provide a GitHub repo slug. Steward fetches your steward.yaml config and VISION.md. The config defines autonomy boundaries — what Steward can handle alone and what needs your approval.
$ steward enroll your-org/deploy-hub
02
Steward takes ownership
Steward begins watching. It classifies issues, fixes bugs autonomously within your limits, flags vision conflicts, and queues major decisions for your review. AI engineering and QA teams handle execution.
03
You check in when you want
Morning check-in: any products unhealthy? Any decisions waiting? Approve what needs approval, read the changelog, and move on. Five minutes. Back to your real work.
The pipeline
Everything flows through the vision.
Bugs get fixed. Small enhancements ship. Major features get deliberated by AI debate teams. Vision conflicts get escalated. You only see what requires a human judgment call.
GitHub Issue
→
Classify
→
Deliberate
→
You Decide
→
Engineer
→
QA
→
Shipped
Bugs and small enhancements skip the "You Decide" step — Steward handles those within your defined autonomy limits.
Your primary touchpoint
The approval queue is your trust interface.
Each item contains everything you need to decide — the proposal, the reasoning, the skeptic's concerns, and Steward's recommendation. No digging into GitHub required.
steward / approvals / deploy-hub
Major Feature
Add LDAP / Active Directory authentication
DeployHub · Issue #47 · Est. 800 lines across 6 files · 3 days eng effort
Steward recommends
✓ Approve
Vision alignment
VISION.md identifies LDAP/AD as "table stakes for any commercial conversation with an organization over 200 employees." This directly serves the Tier 1 enterprise market. The current hardcoded session auth is explicitly noted as MVP-only.
Skeptic concerns
Scope risk: LDAP implementations vary significantly across enterprises. Recommend limiting Phase 1 to simple bind authentication against a single directory. Group-based access control should be a separate work item to keep this bounded.
Engineering analysis
Touches auth middleware, user session model, and configuration. No database schema changes. Existing session management can wrap LDAP-authenticated identities. Go ldap library is mature. Recommend feature flag for gradual rollout.
Capabilities
Six functions of product ownership. All autonomous.
Each capability maps to what a strong product manager does — applied to every product in your portfolio, every day, without headcount.
📊
Product Dashboard
Health status, vision score, work in progress, last activity. Answers "is my product healthy?" in three seconds.
→ PM function: situational awareness
📋
Work Pipeline
Visual kanban of all work items flowing through intake, classification, engineering, review, and completion. See what's moving and what's stuck.
→ PM function: prioritization
✅
Approval Queue
Your only required touchpoint. Full context packages for every decision that exceeds Steward's autonomy — proposal, reasoning, concerns, recommendation.
→ PM function: decision-making
📝
Changelog
Auto-generated release notes in product language. What shipped, why, what was tested. Stakeholders stay informed without you writing a word.
→ PM function: stakeholder communication
🧪
QA Reports
Per-change test results, coverage deltas, regression flags. The audit trail that proves quality, not just velocity.
→ PM function: quality assurance
🧭
Vision Console
Health of your VISION.md — which dimensions are strong, which are vague, where Steward needs clarification. The strategic compass for every product.
→ PM function: strategy alignment
Trust model
You define the boundaries. Steward operates within them.
Autonomy without accountability is recklessness. Steward earns trust by showing its work, respecting your limits, and never exceeding its authority.
You draw the lines
Your steward.yaml defines exactly what Steward can do alone: auto-fix bugs always, auto-approve enhancements under 200 lines, escalate everything else. Change the limits any time.
Steward shows its reasoning
Every classification, every deliberation, every recommendation comes with the full reasoning chain. You see what Steward considered, what the skeptic flagged, and why it recommends what it recommends.
Nothing exceeds authority
Steward never makes a decision above its defined limits. Major features, architecture changes, and vision conflicts always come to you. The approval queue is the human gate — it's sacred.
The road ahead
From maintenance to autonomous product creation.
Steward today keeps products alive. Tomorrow it builds them.
NOW
Reactive PM
Phase 1 — Now
Steward manages existing products. Watches repos, classifies work, fixes bugs, escalates decisions, generates changelogs. Your tools stay alive and aligned with their vision.
Self-Sustaining PM
Phase 2
Steward manages its own infrastructure and its AI engineering teams. It monitors its own health, optimizes its own processes, and scales to manage larger portfolios without additional configuration.
Generative PM
Phase 3
"We need an internal tool that does X." Steward conceives, builds, deploys, and manages new products from a description. Human oversight at the strategic level only.
Under the hood
Built on the ElfTech stack.
Armature powers triage. Quorum runs the AI debate teams that deliberate features. AnvilWorks executes code changes. Steward orchestrates the full pipeline — and logs every decision in a compliance-grade audit trail.
One repo. Five minutes. Steward reads your vision, understands your boundaries, and begins watching. Your internal tools deserve a product owner. Shipping mid-Summer 2026.