Why we're building Elyra Team (and why the CLI stays free)
Elyra started as a tool for one developer. You install it, set an API key, and start coding with an AI agent in your terminal. That's it. Over five thousand weekly downloads suggest it works well enough that people keep coming back.
But something shifts when the second developer on your team installs it. And the third. And the tenth.
The problem nobody talks about
A single developer using an AI agent is, by now, a solved problem. Elyra handles it. Claude Code handles it. Cursor handles it. The tooling is good, and getting better every month.
What isn't solved is what happens when a team uses AI agents on the same codebase, at the same time, with no coordination between them.
Nobody knows what it costs. Five developers, five API keys, two or three providers between them. The monthly bill is somewhere between $200 and $2,000, and nobody can tell you which without logging into five separate dashboards. Finance asks for a number. You spend an afternoon in spreadsheets.
Nobody shares context. Your senior developer spent two hours teaching the agent about your architecture — repository pattern, event-driven notifications, UUID primary keys, the conventions that took the team a year to settle on. That knowledge lives in a memory file on their laptop. The next morning, a junior developer opens a session and the agent knows none of it. They spend another hour re-explaining the same patterns. Multiply that by every new project, every new hire, every fresh checkout.
Nobody sets boundaries. The agent can delete migration files. It can overwrite auth middleware. It can remove a test suite. It won't do these things unprompted, but a careless instruction in a late-night session can cause real damage, and there's nothing between "developer asks" and "agent does."
These aren't hypothetical. They're what happens in every team that adopts AI agents past the first enthusiast.
Three things Elyra Team solves
One bill, full visibility
Team admins register provider API keys once. Developers get a single ELYRA_PRO_KEY environment variable. Every session routes through a managed proxy that handles authentication, tracks usage, and enforces budgets.
For the developer, nothing changes. One variable, and Elyra works exactly as before. The proxy is invisible.
What does change is visibility. A dashboard shows cost per developer, per project, per model. Monthly trends. Budget alerts. CSV exports for finance. The CTO can answer "what are we spending on AI" in ten seconds instead of ten emails.
Per-developer and per-project caps mean nobody accidentally burns through $500 in a weekend on a runaway agent loop. When a developer hits their limit, the session pauses with a clear message. No surprise invoices, no awkward Monday meetings.
Shared memory
Elyra already generates project memory after each session — architecture decisions, patterns learned, conventions discovered. That memory has been local. Team makes it shared.
The mechanism is unglamorous, which is the point. Memory lives in .elyra/memory/ as markdown files, versioned in git. The agent writes summaries. Developers pull them with their normal workflow. The agent reads them on session start.
The Team layer adds real-time sync (no waiting for git push), access control (who can write to memory), and a review workflow (approve or reject what the agent learned before it propagates to the team).
The practical effect: a new developer starts their first session on the project, and the agent already knows everything the senior developers have taught it. No onboarding doc, no "read the wiki," no tribal knowledge trapped in someone's head. The agent carries it forward.
Guardrails
Rules the agent cannot break, even if asked.
# .elyra/guardrails.yml
rules:
- never delete committed migration files
- never modify auth middleware without confirmation
- never write to .env.production
- always run tests after editing more than 3 files
When a guardrail triggers, the agent explains why it can't proceed and suggests an alternative. Admins get notified. The rule is enforced at the tool-execution level — there's no way to talk the agent out of it from chat.
This matters for regulated industries — finance, healthcare — where audit trails and access controls aren't optional. It also matters for any team where the cost of a mistake is higher than the cost of a confirmation dialog. Which is, honestly, most teams.
What stays free
Everything. The CLI, every extension, every command, every theme, every feature we've shipped and will ship. Elyra is open source and stays open source.
Team is for organizations that need the coordination layer on top. If you're a solo developer, you never need it. If you're a team of twenty, the coordination problem is real, and Team is the answer.
Free Team CLI + all extensions ✓ ✓ 30+ LLM providers ✓ ✓ Sessions, memory, compaction ✓ ✓ Themes, blueprints, snippets ✓ ✓ Smart routing ✓ ✓ Managed proxy + cost dashboard — ✓ Per-developer budget caps — ✓ Shared team memory with sync — ✓ Guardrails — ✓ Audit log — ✓
Pricing
$25 per developer per month. You bring your own provider API keys. We don't mark up token costs — you pay Anthropic, OpenAI, or whoever directly at their published rates. Team pricing covers the proxy, the dashboard, memory sync, guardrails, and audit logging.
No per-token fees. No usage tiers. No overages.
The waitlist
We're building Team for early access in June 2026. If your team uses Elyra — or any AI coding agent — and the coordination problem resonates, the waitlist is at elyracode.com/team.
Three fields: email, team size, and optionally what your biggest pain point is with AI agents in a team. That last one is genuinely useful to us. The answers shape what we build first.
We'll reach out when it's ready for early access. No newsletter, no "thought leadership" emails. A ping when you can try it.
Why now
The market is moving fast. Anthropic launched Claude Managed Agents. Every IDE is bolting on AI features. The number of developers using AI agents daily is climbing in a way that doesn't level off any time soon.
But the tooling, almost universally, assumes a single user. One person, one API key, one context, one set of preferences. The moment you scale past that, you're on your own.
We think the team problem is where the real value sits. Not in making the agent smarter — the model providers have that covered — but in making it safe, visible, and shared across an organization.
The CLI is the foundation. Team is the business. Both belong here.