Cascade is live: meeting in, pull request out.

Today is launch day for our flagship open-source project. Cascade is an AI agent that takes a meeting recording, a tracker ticket, or a one-line prompt, and ships a tested pull request. It is on PyPI as of this morning. You can install it with pip install cascade-agent, run cascade try, and have a working end-to-end run in about thirty seconds.

It is MIT licensed, self-hosted, and works with whatever LLM, VCS, and issue tracker your team already uses. No new vendor relationship. No new bill. Your code never leaves your org except to the LLM provider you chose.

The gap we set out to fill

There are a lot of AI dev tools right now. Cursor, Copilot, Windsurf, Devin, Aider, Continue, Claude Code, the list keeps growing. Most of them are great at one thing: helping an individual developer write code faster inside an IDE. None of them really address the part of the workflow that happens before the developer opens the IDE.

The chasm:

1. A team has a meeting and decides what to build next.
2. Someone takes notes (badly).
3. Someone else translates the notes into tickets in Jira or Linear.
4. An engineer reads the tickets, often days later, and tries to reconstruct what was actually meant.
5. The engineer writes the code, the tests, and the PR description.
6. By the time it ships, the original intent has been telephone-gamed through four or five documents and three or four people.

Information leaks at every transition. The senior engineer who heard the original conversation is rarely the same person writing the final code. The result is what every team has lived through: PRs that solve a slightly different problem than the one the meeting was about.

The second gap is just as real. When developers use AI individually, each session is isolated. The architectural decisions made in last week's meeting are not in anyone's AI context. The coding conventions discovered by one dev are not shared with anyone else's AI. Senior knowledge does not compound across the team because every junior is starting from zero with their copilot. Teams collaborate in human channels. The AI side of the workflow is single-player.

What Cascade does

You enter the pipeline from one of three on-ramps:

• From a meeting: cascade ingest standup.mp3 transcribes audio, identifies speakers, extracts user stories with acceptance criteria, and walks you through review before any code gets written.
• From a ticket: cascade ticket jira:PROJ-123 pulls the requirement from your tracker and ships a PR with tests.
• From a prompt: cascade prompt "Add /health endpoint" for the small features that pile up on every team's backlog.

From whichever on-ramp you started, the pipeline runs eight stages: plan, code, apply, install, test, commit, push, open a pull request. Each stage has live progress feedback. Each stage reads from your team-memory/ directory, where you keep your team's conventions, decisions, glossary, and prior work. That memory layer is the thing that turns generic AI output into code that fits your codebase.

Two human gates are baked in. The first is story review, where you accept, edit, or reject what the LLM extracted before any code gets generated. The second is PR review, where you approve the change before it merges. Cascade does not have merge permissions on any repo, ever. It is built for trust, not for autonomy theatre.

The choices we made (and why)

Cascade exists in a crowded space. Here is what we decided to do differently, and the reasoning:

Self-hosted by default

Most AI dev tools are SaaS-only. That is a non-starter for teams in regulated industries, teams with legal restrictions on code residency, and teams that just do not want one more vendor. Cascade runs on your machine or your CI. The only place your code goes is the LLM provider you explicitly configured. We support five (Anthropic, OpenAI, Google Gemini, Claude Code SDK, Ollama) so even if your company has an existing relationship with one of them, Cascade probably fits.

Bring your own AI, your own VCS, your own tracker

Switching providers is a single config command. We support four VCS providers (GitHub, GitLab, Bitbucket, Azure DevOps) and five issue trackers (GitHub Issues, Jira, Linear, Azure Boards, GitLab Issues). The matrix matters because real teams are not on a single stack; they are wherever they ended up after years of acquisitions, migrations, and individual preferences.

Polyglot from day one

Eight built-in language profiles cover Python, TypeScript, JavaScript, Go, Rust, Java, Ruby, and C#. Adding a ninth language is a single registry entry; there is no plugin system to learn. We made this choice early because we did not want Cascade to be "the Python tool" or "the TypeScript tool." We want it to be the tool that meets you where your codebase already is.

Team memory as a first-class concept

The team-memory/ directory contains five files: conventions.md, decisions.md, glossary.md, constraints.md, and prior-work.md. Every LLM call across every stage reads from this directory. The challenge was avoiding prompt bloat as the memory grows. We solved it with a bounded budget (20,000 chars per call by default), proportional per-file truncation, and stage-aware weighting so the extractor sees more glossary and the coder sees more conventions. It scales without prompts scaling with it.

Cost visibility on every call

Every LLM call surfaces its estimated cost in the CLI output. After a multi-story build, a session total prints. cascade build --max-cost 5.00 aborts between stories if cumulative cost would exceed your budget. We built this because nobody likes a surprise $200 bill from their dev tool.

The honest state of the alpha

Cascade is published, the install works, the pipeline runs end-to-end, the docs are real. What it is not yet:

• Battle-tested on real production repos. We have run it on toy projects and ThinkNext internal work. We have not yet pointed it at a 50-engineer monorepo. Bug reports very welcome.
• Validated against live Jira / Linear / Azure DevOps instances. The integrations were built against API documentation. We tested with mocks. Real-world quirks will surface as we get real users.
• Stable. The version is 0.1.0a1 for a reason. The public API may shift before we cut 0.1.0 stable. We will not break things gratuitously, but we reserve the right to fix mistakes.

The right way to interpret this release: feature-complete enough that you can run the whole pipeline today, honest enough about the alpha state that you know what you are getting. We would rather ship and iterate with real users than polish in private for another six months.

What is next

On the immediate roadmap:

• 0.1.0a2: bug fixes from early adopters, smoothing the install on edge platforms (Windows native, Apple Silicon variants), and a couple of usability papercuts in cascade review.
• 0.1.0 stable: after enough real-world usage that we feel comfortable making API guarantees. Target is roughly six weeks from now, conditional on what we hear from users.
• 0.2: a PR-comment iteration loop (Cascade reads review comments and ships a follow-up commit), team-memory autosuggest based on shipped PRs, and per-stage model routing (planner on a cheap model, coder on a strong one).

The soft launch target for the broader announcement (Hacker News, dev Twitter, the rest) is September 15, 2026. Between now and then we are running it on real client work and tightening everything that hurts.

Try it

pip install cascade-agent
cascade doctor
cascade try

That runs the install, checks your setup, and runs a built-in toy story end-to-end in a temp directory. Takes about thirty seconds. Touches nothing in your real repos.

For the full walkthrough, see the getting-started guide. For the source, cascade on GitHub. For bugs and feature requests, file an issue or email hello@thinknextsoftware.com.

Thank you for reading this far. If you try Cascade and either love it or hate it, we want to hear about it.

---

Cascade is built by ThinkNext Software Solutions. We build software and place engineering talent, augmented by AI at every step.