Felan is an agentic engineering platform — the team layer for AI-native software development. It gives engineering teams cloud background agents, shareable sessions, shared team knowledge, and visibility across delegated work inside the tools they already use.
Agentic engineering platform
Copilots make engineers faster. Felan makes the team faster.
Felan gives your engineering team cloud background agents and an AI-native way of working built into software — shared team knowledge, full visibility, inside the tools you already use.
Works in Slack, GitHub, Linear, Jira · Bring your own model keys · Every session visible
felan · sessions
SRE agentImplement
RunningInvestigate failing deploy on main
09:41:02Pulled last 12 commits on main
09:41:18Correlated failure with migration 0142
09:41:47Drafted rollback PR — awaiting review
Developer agentGroom
Waiting on humanTurn feedback thread into groomed tickets
QA agentReview
DoneGenerate and run checks for #4821
General Purpose agentCapture
DoneSummarize incident retro into docs
The gap
Your Engineers Got Faster. Your Team Did Not.
AI adoption happens one engineer at a time. Claude Code, Cursor, and Copilot changed individual work — but the team layer around it still runs the old way.
Uneven adoption
Some engineers are power users; others are falling behind. The team moves at the speed of its slowest AI adopter.
Fragmented workflows
Every engineer builds their own setup — tools, prompts, habits. Nothing converges into a shared way of working.
Knowledge that scatters
The prompt that landed, the tricky bug, the pattern that worked — it stays in one person's chat history. The team re-discovers old answers.
A copilot helps one person while they work. A background agent carries delegated team work forward when nobody is prompting it.
| Capability | Copilot | Felan background agents |
|---|---|---|
| Primary user | One engineer | The engineering team |
| Trigger | A person prompts it | Events, schedules, delegated responsibilities |
| Context | Local to a chat or editor | Shared across the team's tools and history |
| Memory | Personal and fragmented | Team-level — knowledge compounds |
| Governance | Whatever the individual decides | Team- and agent-level permissions — you choose who stays in the loop |
| Output | Advice for a person to act on | Work advanced in Slack, tickets, Git, CI, docs |
The product
A Team’s Way of Working, Built Into Software
Opinionated if you’re starting out — stages, skills, and agent personas from day one. Configurable and extensible if you already have your own.
An AI-native SDLC, out of the box
Felan ships a working way of working: predefined stages and skills that map to the software development lifecycle, and agent personas for each role. Already have your own process? Felan blends with it instead of replacing it.
- Capture, Groom, Plan, Implement, Review — predefined stages and skills
- Developer, QA, SRE, and General Purpose agent personas
- Bring your own skills — Felan blends them with what it ships
Capture
+ skill+ custom
Groom
+ skill+ skill
Plan
+ skill+ custom
Implement
+ skill+ skill
Review
+ skill+ custom
Runs in the background
Agents fire when something happens — a PR opens, a ticket updates, an alert triggers, a schedule ticks. Sessions run in the cloud, so work keeps moving without an engineer driving every step.
- Event and schedule triggers — no one has to remember to start
- Sessions start, stop, and resume from anywhere
- Shareable sessions — one engineer picks up where another left off
14:02:11PR #4821 opened
14:02:14QA agent session started
14:03:40Checks generated and run
14:05:22Summary posted to Slack
Team knowledge that compounds
Between sessions, Felan reviews recent work and distills it into reusable team knowledge — recurring patterns, fix recipes, conventions. What one engineer learns, the team keeps.
- Learnings become shared memory, not one person's chat history
- Agents start from what the team already knows
- Less re-discovering the same context every session
Team knowledgesample data
Flaky deploy fix recipe
distilled from session · Jul 2
API naming conventions
distilled from session · Jun 28
Release checklist
distilled from session · Jun 24
Visibility and guardrails
See what agents are doing in real time — with full transcripts of every past session and a per-team activity feed. And set what's allowed at two levels: who on the team can change the SDLC, models, budgets, and skills, and what tools, data, and systems each agent can touch. Trust comes from visibility, not promises.
- Live sessions, full transcripts, per-team activity feed
- Team-level roles: who configures the SDLC, models, budgets, skills
- Agent-level permissions: what each agent can use and touch
Activity feed
10:12
DoneDeveloper agent opened PR #918
10:26
Waiting on humanQA agent flagged 2 checks
10:31
RunningSRE agent reading logs
SRE agent
permissions
read logsallowed
open PRsallowed
apply fixes to productionneeds a human
Your models, your keys, your budgets
The agent harness is model-portable. Plug in the provider you trust, bring your own API keys, and switch models without changing how the team works. Spend stays governed: budgets, quotas, and attribution that shows exactly where it went.
- Bring your own model keys — switch providers without retraining the team
- Budgets and quotas per team and per agent
- Cost attribution: which automations, agents, and sessions consumed the spend
Models & keyssample data
Anthropic
API key: ••••••••OpenAI
API key: ••••••••Google
API key: ••••••••Monthly budgetsample
Examples
What Teams Delegate
Every team’s bottleneck is different. These are the kinds of work engineering teams hand to Felan — each one an example, none of them the ceiling.
Product & planning
Feedback threads become groomed tickets. Felan captures what was said, drafts the ticket, and keeps it in sync with the discussion — so planning starts from written-down work, not memory.
Development
The follow-ups that never reach the top of the list — migrations, small fixes, dependency bumps — delegated, carried to a PR, and brought back for your review.
QA & release
As AI writes more code, review and verification fall behind. A QA agent reviews changes, generates and runs checks, and investigates failures — the judgment calls stay with you.
On-call & incidents
When the alert fires, the first 15 minutes are toil — logs, traces, recent commits. An SRE agent does the legwork and proposes a fix; on-call approves instead of digging.
Personas are configurable and extensible — teams define their own and decide what to delegate next.
Integrations
Works With Your Entire Stack
17 integrations and counting — agents pick up triggers in your tools and post results back into the same channels.
Source control
Communication
Issue tracking
Documentation
Other
TR
TestRailSoonDon’t see your tool? We add integrations in days — just tell us →
Proof
Start Where the Pain Is
Felan doesn’t ask you to change how the team works on day one — it starts inside your tools, on the bottleneck you name.
01
Connect
Plug Felan into the tools you already run — chat, code hosting, tickets, CI.
02
Adopt or blend
Start with Felan's way of working out of the box, or blend your existing skills and process into it.
03
Delegate and watch
Hand over one responsibility. Follow every session live, read the transcripts, and choose where humans stay in the loop.
In production with engineering teams:
InvendaNEGTokiGoodShapeSportAitchQ
Pricing
Start with Team capabilities. Choose what fits after 14 days.
Every new Felan team gets 14 days of Team capabilities, with no card required. After the trial, continue on Individual for €0, upgrade the whole team for €99/month, or talk to us about Enterprise.
Individual
Personal access with your own model credentials
€0
- 1 member and 1 repository
- 1 concurrent worker
- 200 agent minutes per month
- Git and messaging integrations
- Bring your own model credentials
- 30-day retention and self-serve support
Team
14-day trialShared access and higher limits for teams using Felan together
€99/month
Flat per team
- Unlimited team members and repositories
- Up to 5 concurrent workers
- 5,000 agent minutes per month
- All integrations and private connectivity
- Managed AI access with separately funded credits
- 90-day retention and standard support
Enterprise
Custom commercial terms, limits, security, and support
Custom
- Custom limits and retention
- SSO and SAML
- SLA guarantees
- Dedicated support
- Custom integrations and connectivity
Team is one flat subscription for the whole team, not a per-seat price. Managed AI usage is funded separately through AI credits. Agent-minute allowances are included usage limits, not metered billing rates.
Questions Engineering Leaders Ask
A coding copilot helps one engineer while that person is prompting it. Felan carries delegated team work forward in the background, using shared context and returning progress and results through the team's existing systems.
Felan is built for engineering organizations adopting AI across the software development lifecycle. Buyers are typically CTOs, VPs of Engineering, and platform leaders; champions are often AI-forward senior, staff, or platform engineers.
Teams can delegate work such as turning feedback into groomed tickets, carrying small development tasks toward a pull request, reviewing and checking changes, and investigating incidents before a human approves the next step.
No. Engineers retain direction, judgment, and approval. Felan carries delegated work between those decisions and keeps the session history visible to the team.
Teams choose what to delegate. Cloud sessions can be started, stopped, resumed, and shared, while the team activity feed and full transcripts keep the work visible. Event- and schedule-based automations can trigger repeatable workflows where configured.
Yes. Felan provides SDLC stages, skills, and role-based agent patterns, while allowing teams to connect their existing process, tools, model providers, and company-built agents.
No. Felan runs on a model-portable harness. Teams can bring their own model keys and change providers without changing the way sessions and delegation work.
Felan integrates through its tool layer with systems including Slack, Microsoft Teams, GitHub, Linear, Jira, Azure DevOps, and Asana. Agents can receive context from these systems and return progress or results to the team's workflow.
Individual is €0. Team is €99 per month as a flat subscription for the team, not a per-seat price. Enterprise has custom commercial terms. Every new team starts with 14 days of Team capabilities, with no card required.
Copilots Made Your Engineers Faster. Now Make the Team Faster.
Felan is how engineering teams move from scattered individual AI wins to team-level productivity.