Company: The Agentic Future (services + software)
Product: FlywheelCI (web & mobile), shipped as source code so customers can run and extend it inside their stack
What we do: Teach teams how to use agents for business workflows and agent‑driven engineering, then co‑deliver rapid prototypes
The problem we kept seeing (and living)
The classic way of moving from idea → validation → scoping → “go build” is slow and brittle. Docs sprawl, specs drift, and hand‑offs create rework. Meanwhile, modern agent tooling (think spec writers, code‑assistants, test authors) can collapse these steps, but most teams lack a simple, disciplined runway to apply them.
We needed a tool that matched our services and methodology: move fast with agents, without losing the guardrails. Nothing off‑the‑shelf fit. So we built FlywheelCI.
What FlywheelCI is
A lightweight stage‑gate and portfolio app, redesigned for agent‑driven work. Across the top of each initiative is a clear runway (G0 → G6). Each gate asks for the minimum artifacts to move forward: no ceremony, no bloat.
How the flow works (high level)
- Gate 0–1: Intake → Formal Brief. Drop in interview transcripts or capture by voice with mobile real‑time transcription (works offline for field interviews). Transcripts are edited with provenance, and agents produce a structured Brief with a completeness score and sources. Approvers sign digitally.
- Gate 2: Analysis & Decision Memo. Scorecards, dependencies, and a 3‑year NPV/IRR/Payback are generated via a deterministic engine; every assumption links to a transcript span or an explicit user input. Finance must approve before the gate advances.
- Gate 3: Prioritization & Roadmap. A knapsack‑style prioritizer respects capacity constraints and produces A/B roadmaps for approval.
- Gate 4: Spec & TDD Pack. Agents draft a PRD‑style spec, process maps, acceptance criteria, unit‑test skeletons, and create issues in Jira/GitHub with clear DoR/DoD, so engineering starts cleanly.
- Gate 5–6: Build tracking → Benefits realized. Exec‑friendly, read‑only repo views summarize PRs and surface hotspots; once shipped, actual results are entered/imported and compared to projections with a variance waterfall. Weekly digests and exports keep stakeholders aligned.
Dashboards for leaders
Backlog dollars, gate throughput, capacity vs demand, projected vs realized savings, and repo signals: filterable and exportable.
Purpose‑built agents (tailored prompts + toolkits)
- Interviewer: conducts discovery interviews and captures transcripts.
- Summarizer: condenses content into concise, actionable summaries.
- Critic: reviews outputs and suggests improvements/clarifications.
- Ideator: generates candidate ideas from prompts or transcripts.
- Brief Composer: drafts and iterates the idea brief (v1+).
- Complexity Assessor: estimates complexity/effort and key drivers.
- Dependency Mapper: identifies upstream/downstream dependencies and blockers.
- Risk Agent: enumerates risks, impact, likelihood, and mitigations.
- Financial Modeler: produces 3‑year financials, NPV/IRR/payback, sensitivity.
- Portfolio Prioritizer: ranks ideas by weighted criteria and constraints.
- Roadmap Planner: sequences work into a pragmatic roadmap.
- Spec Writer: composes a detailed technical specification from artifacts.
- Process Mapper: drafts process maps (flows, roles, steps).
- Test Author: proposes test plans/cases and acceptance criteria.
- Ticketizer: breaks scope into tickets/user stories with DoR/DoD.
- Repo Summarizer: summarizes repository activity, PRs, hotspots.
- Code Q&A: answers code questions and cites relevant files.
- Benefits Tracker: records realized savings over time.
- Retro Writer: drafts retrospectives and improvement actions.
Portfolio clarity without spreadsheets
Scorecards, risks, and dependencies roll up so leaders can see what’s blocked and why, and make trade‑offs quickly.
Why Finance Will Love It
- Deterministic math. NPV/IRR is computed by a dedicated engine (not an LLM) with unit tests; sliders expose sensitivity to adoption, discount rate, and FTE costs.
- Line‑of‑sight to sources. Every number in the memo is traceable to transcripts or explicit inputs; PDFs export for audit.
- Governance & audit. Role‑based approvals, digital signatures, and a full audit trail; RLS by org, consent for recordings, encryption, and SSO.
Source‑available by default
When you work with us, you receive the source code to FlywheelCI. Run it behind your SSO, wire it to your systems, extend the agents, and keep the changes.
How the software + our services fit together
Our method: Teach → Prototype → Transfer
- Teach (Agent literacy & patterns). We orient your team on high‑leverage agent patterns (business workflows and engineering co‑pilots) and map them to your environment.
- Prototype (in FlywheelCI). We give your engineering team FlywheelCI free of charge to implement in your stack and with your services. Run real initiatives through G0–G6. Agents co‑produce briefs, flows, tests, and tickets as the artifacts emerge.
- Transfer (own the discipline). We harden the gates for your context, create playbooks (e.g., “New integration,” “Pricing change”), and hand you the codebase and operating rhythm.
Outcomes our customers see in practice
- Shorter, clearer path from discovery to scoped work because agents sit inside the gate process.
- Cleaner hand‑offs: tickets and tests are generated from the exact same scope and decision memo.
- Less debate, more decisions: scorecards and dependency views make trade‑offs explicit.
- Repeatability: teams reuse deliverables and playbooks rather than reinventing specs.
Why we built instead of buying
- Discipline without drag. We wanted the smallest set of deliverables that unlock the next gate.
- Agents in the loop. The value shows up when spec, process, tests, and tickets are generated where the information lives.
- Customer ownership. Our clients need to host, extend, and govern the tool like any internal app: that means source code, not a black box.
- Web + mobile. Real work happens everywhere; FlywheelCI is designed for on‑the‑go validation and decisions.
What you get when you engage us
- FlywheelCI source code (web & mobile) to run in your environment
- Configured stage‑gates suited to your portfolio (G0–G6 by default)
- In‑product agents (Spec Writer, Process Mapper, Test Author, Ticketizer) tuned to your workflows
- Playbooks & templates for repeatable work types
- A working prototype (or three) delivered through the pipeline, so your team learns by doing and keeps the artifacts
Who this is for
- Product & engineering orgs adopting agent‑driven delivery
- Innovation teams validating and scoping bets quickly
- Services groups who need consistent, portable hand‑offs to engineering
Stop renting your roadmap
Work with us to stand up FlywheelCI, run real initiatives through the gates, and leave with the tool, the playbooks, and the muscle memory to keep shipping fast.
See a live walkthrough. Talk to us about deploying FlywheelCI in your stack.