In many insurers I meet, the real trouble is not the straightforward claims that follow a clear path. The real trouble lives in the complex cases. These include big accidents, business interruptions, edge cases, and disputes. Such cases suddenly cut across underwriting, legal, operations, IT, and external experts. On the outside, the customer experiences long silence. They receive generic status emails. Customers also need to call three times to “find someone who knows my case.” On the inside, teams see the claim bounce from inbox to inbox, with nobody quite owning the whole journey.

The usual response is to add more: more rules, more exception codes, another steering committee, a new case‑management system. Sometimes that helps for a while. Often, it just gives the work more places to get stuck. From an Agile Organization (AO) perspective, a complex claim is not a ticket to be pushed through departments. It is a flow that requires the right people to be around it at the right time. These people should have enough authority to act. In this issue, I share a story from a mid‑size insurer. They created a small “complex‑claim swarm.” I also share a simple move you can try if you recognize similar patterns in your own organization.

From the field: a small swarm for big claims

A few years ago, I was invited to work with a regional insurer handling health and property claims. They were not a global giant. They had a few hundred thousand customers and a few dozen people in claims. Their world had become complicated. New products, tighter regulations, and more demanding customers meant that the number of truly complex claims was rising. These cases were exactly the ones leadership cared about most. They were also the cases most likely to blow through the promised timelines.

When we looked at one of these complex claims in detail, the journey was sobering. A customer reported a serious incident through the call center. The front‑line handler opened the case and requested documents. Once the first papers arrived, the file went to a more experienced handler. This handler involved underwriting to check coverage. Then, legal reviewed the wording. Next, an external assessor and sometimes a medical expert were consulted. Each person worked from their own queue. Questions came back to the handler, who sent more emails, requested more documents, and updated the system fields. Weeks later, the customer still had no clear answer – but the case had touched six or seven desks.

From an AO perspective, nothing was “wrong” with any individual. Each function did its job. The system, however, had no real swarm around the work. So we proposed a small experiment. We worked together with the head of claims. We defined a narrow slice, focusing on complex cases. These cases were above a certain size and had specific characteristics. For that slice, we created a “complex‑claims swarm”. It included one senior handler, one underwriter, one legal contact, and one operations/IT liaison who understood the workflow rules. They got explicit authority over that slice for eight weeks.

The rules of the swarm were simple. First, every new complex claim in that slice was reviewed together in a short huddle. Second, the swarm met briefly three times a week. They decided on next steps, resolved questions on the spot, and adjusted sequencing across their queues. Third, the head of claims committed to backing their decisions inside the wider organization.

Within a few weeks, the data started to move. Average cycle time for that slice dropped, the number of “where is my claim?” calls went down, and escalations to the head of claims all but disappeared. But the most interesting effects were not in the metrics. In one session, the legal contact identified a standard clause. This clause caused a loop of reviews in almost every complex case. In another session, the IT liaison realized that the workflow engine forced a return to an earlier step. This happened even when the decision was actually clear.

At the end of the pilot, the senior handler said something that stayed with me. “For the first time, I feel like we are looking at the same claim together. We are not looking at five different versions of it in five different systems.” That sentence contains the AO question I’d invite you to reflect on. In your complex work, can a small, committed swarm focus on a narrow slice of cases? Could it provide more help than another rule? Could it offer more than an additional meeting? Could it be more beneficial than another system?

Try this AO move this week – for complex claims

You don’t need a big reorganization to change how complex claims flow. A good first AO move is to look closely at one real claim. Then design a small swarm around that type of work. Avoid pushing it through the usual departmental hops.

  1. Pick one real complex claim. Choose an actual case from the last few months that was painful. It could have been high value, involved multiple parties, had a long duration, or included repeated complaints. Avoid a theoretical example – the point is to see your real system at work.
  2. Map the end‑to‑end journey on one page. From first notification of loss to final payout (or closure), identify each person or group who touched this claim. This includes call center, front‑line handler, senior adjuster, underwriting, legal, external assessor, medical expert, IT, and suppliers. Draw the steps in the order they really happened. Include back‑and‑forth loops, extra checks, and manual spreadsheets. Add workarounds that never appear in the official process.
  3. Circle the 1–2 worst friction points. Identify where the claim waited the longest. Notice if it bounced between people or kept coming back for “one more clarification.” This might be due to waiting for documents. It could also be because of legal wording debates. Unclear medical opinions might also contribute, or system blocks that forced re-work. Circle just one or two hotspots and note what seemed to be happening there.
  4. Ask the complex‑claim swarm question. For those hotspots, consider this: “If we formed a small swarm around this kind of claim, who would we need? Who should join the conversation from the beginning?” In many insurers, the swarm typically includes a senior handler, an underwriter, and a legal contact. It also includes someone who understands workflow/IT rules. Sometimes, a medical or supplier liaison is part of the swarm as well.
  5. Run a small, time‑boxed swarm pilot. For the next 3–5 complex claims of this type, invite that swarm into a short huddle when the claim comes in, plus a brief regular check‑in (e.g., two or three times a week). Allow them to make end‑to‑end decisions for this slice. Ensure this is within your existing policies and risk appetite. Do this without adding a new permanent committee.

If you try this, don’t only watch the average cycle time. Pay attention to what your swarm starts noticing about rules, systems, and handoffs. These are insights you could not see from a single desk. That is usually where AO’s work on complex claims really begins.

You want more?

If this experiment sparks something, please reach out. You may want to explore how AO could look in your own organization. You can book a short conversation with me. Book it here: https://menschgeist.youcanbook.me/.

If you prefer to read first, you’ll find AO e‑books and materials here: https://payhip.com/menschgeist.

If you want to dive deeper into the broader #AO Method, #Training, #Coaching, and resources, visit https://agile-organization.com.

The AO Method (Agile Organization/Agile Organizations Method) is Pierre Neis’s own framework. It is distilled from more than a decade of agile coaching. This work includes organizational transformation across many companies, cultures, and contexts. It is based on Practice-based patterns, “Agile as system dynamics,” Organic/anthropomorphic view of organizations. Initial consolidation in 2018.

When your product team becomes the bottleneck

In many software companies, the product team slowly turns into an organizational bottleneck. Everything runs through the same few people: feature ideas, customer escalations, incident decisions, and Roadmap calls. Engineers wait for clarification. Customer success waits for answers. Leadership waits for commitments. The product trio sits in back‑to‑back calls trying to stitch it all together. On paper, the organization looks agile: squads, sprints, roadmaps. In everyday work, it feels like an airport. Every flight must ask the same tower for permission to move.

When I meet these teams, I rarely see “lack of discipline” or “not enough process.” I see a system that has grown more complex than its current design can handle. Work wants to flow as end‑to‑end slices of value for specific customers or domains. Instead, it zig‑zags through queues, hand‑offs and status meetings. From an AO perspective, a feature or incident is not a ticket to be pushed through functions. It is a piece of work that needs the right people around it at the right time. In this issue, I share a story from a software product team. They shifted from central routing to a small “feature swarm.” I also describe a concrete AO move. You can try it if your own product team is starting to feel like the bottleneck.


From the field: a feature swarm for a stuck product

A mid‑size SaaS company asked me in when one of their core products started missing every meaningful date. The product team was small. It consisted of one product manager, one designer, a tech lead, and about eight engineers. However, the dependencies around them were significant. Sales wanted customizations. Customer success brought urgent requests. Marketing needed dates for campaigns. Security had its own backlog of fixes. Operations pushed for more observability work. Every Roadmap conversation ended with the same feeling. “We are doing a lot of work, but nothing important is getting through.”

We sketched the journey of one “simple” feature, requested by a strategic customer. The original request came through the account manager. It was translated into a ticket and discussed in refinement. The task was sliced in sprint planning and half‑implemented by one engineer. Meanwhile, another engineer was fixing production issues. Then, the task was blocked while waiting for an API change from another team. Testing happened late, documentation lagged, and marketing found out only when the feature was already live. At every step, people did their best. The system as a whole, however, made it very hard for this feature to move smoothly from idea to impact.

From an AO lens, the pattern was familiar. Everyone optimized their own queue. Nobody owned the end‑to‑end flow of value for this customer. So we proposed a small experiment. For a narrow slice of work, we focused on a cluster of related features for exactly this strategic customer segment. We created a “feature swarm.” It included the product manager, designer, and tech lead. One engineer from the team, a representative from customer success, and someone from operations were also part of it. Their mandate was simple: for the next eight weeks, this swarm owned that slice of work end‑to‑end.

The rules of the swarm were deliberately light. First, any new request in that slice started with a short swarm huddle. The account manager and product manager clarified the real need. The engineer and ops person quickly assessed constraints. Together, they agreed on what “good enough” meant for this iteration. Second, the swarm met three times a week for 15–20 minutes. They decided the next moves across design, build, rollout, and communication in one conversation, not four separate meetings. Third, the head of product committed to protecting a fixed capacity for this swarm and backing their trade‑off decisions.

The visible changes came quickly. Features for that segment started to land in small, coherent increments that customers could actually use. The team cut down on rework because customer success and ops were involved early, instead of discovering gaps after launch. Perhaps more importantly, the product manager stopped acting as a permanent router of every question. In one retro, they said: “For this part of the product, I finally feel like we are a team. We are truly working together.” They felt like they were not just a set of queues with one person in the middle. That observation holds the AO question I would invite you to explore. In your product organization, where would forming a small, focused team around a slice of value be more beneficial? Could this approach serve you better than one more steering meeting or dependency board?


Try this AO move this week – for software product teams

You don’t need to redesign all your teams to start working differently. A pragmatic AO move involves taking one important slice of product work. Treat it as something a small swarm owns together. This method avoids letting it trickle through everyone’s backlog.

  1. Pick one slice of value that really matters. Choose a concrete, near‑term piece of work. It could be a feature cluster for a key customer segment. It might be a reliability improvement for a critical flow. Alternatively, consider the handling of high‑severity incidents for one product. It should be important enough that people feel the pain today.
  2. Map how this work actually flows today. On one page, sketch the real path from “we should do this” to “customers are using it and it’s stable.” Break it down into steps: product discovery, design, implementation, review, testing, rollout, communication, and support. Include the people who actually touch it – not just roles on an org chart.
  3. Identify your minimal swarm. Looking at that map, ask yourself: “Who are the 4–7 people who need to be in the same conversation? They should be involved in this slice from the start.” In many software contexts, the group will include roles like product manager, tech lead, and engineer(s). It might also involve a designer/UX, someone from customer success or support, and an operations/SRE/security professional, depending on the work.
  4. Run a four‑week feature‑swarm experiment. For the next one or two items in that slice, bring this swarm together for:
  5. Watch what they notice, not just what they ship. Track basic metrics like cycle time and rework. Also, pay attention to what the swarm notices. They see recurring blockers, missing signals between teams, and areas where your tooling or organizational structure hinders the flow. Those insights are usually your best guides for the next AO‑driven changes.