Attach:
@Mod.EventBusSubscriber(modid = "shadowmobs", bus = Mod.EventBusSubscriber.Bus.FORGE)
public class CapSetup {

    private final static ResourceLocation WORLD_CAP = new ResourceLocation("shadowmobs", "worldcap");
    private final static ResourceLocation PLAYER_CAP = new ResourceLocation("shadowmobs", "playercap");

    @SubscribeEvent
    public static void onAttach(AttachCapabilitiesEvent<World> event) {
        BooleanCapability.Provider provider = BooleanCapability.Provider.from(ShadowMobs.booleanCapability, BooleanCapability::new);
        event.addCapability(WORLD_CAP, provider);
    }

    @SubscribeEvent
    public static void onAttachPlayer(AttachCapabilitiesEvent<Entity> event) {
        if (!(event.getObject() instanceof PlayerEntity)) return;
        BooleanCapability.Provider provider = BooleanCapability.Provider.from(ShadowMobs.booleanCapability, BooleanCapability::new);
        event.addCapability(PLAYER_CAP, provider);
    }
}

Cap-Class:
public class BooleanCapability implements INBTSerializable<CompoundNBT> {

    private final Map<String, Boolean> data;

    public BooleanCapability() {
        this.data = new HashMap<>();
    }

    public void putData(String key, boolean obj) {
        this.data.put(key, obj);
    }

    public boolean getData(String key, boolean def) {
        if (!data.containsKey(key)) return def;
        return data.get(key);
    }

    public Set<Map.Entry<String, Boolean>> getAllData() {
        return this.data.entrySet();
    }

    @Override
    public CompoundNBT serializeNBT() {
        CompoundNBT nbt = new CompoundNBT();
        getAllData().forEach(entry -> {
            nbt.putBoolean(entry.getKey(), entry.getValue());
        });
        return nbt;
    }

    @Override
    public void deserializeNBT(CompoundNBT nbt) {
        nbt.getAllKeys().forEach(key -> {
            putData(key, nbt.getBoolean(key));
        });
    }

    public static class Storage implements Capability.IStorage<BooleanCapability> {

        @Nullable
        @Override
        public INBT writeNBT(Capability<BooleanCapability> capability, BooleanCapability instance, Direction side) {
            return instance.serializeNBT();
        }

        @Override
        public void readNBT(Capability<BooleanCapability> capability, BooleanCapability instance, Direction side, INBT inbt) {
            instance.deserializeNBT((CompoundNBT) inbt);
        }
    }

    public static class Factory implements Callable<BooleanCapability> {

        @Override
        public BooleanCapability call() {
            return new BooleanCapability();
        }
    }

    public static class Provider implements ICapabilitySerializable<CompoundNBT> {

        private final Capability<BooleanCapability> capability;
        private final LazyOptional<BooleanCapability> implementation;

        public Provider(Capability<BooleanCapability> capability, LazyOptional<BooleanCapability> implementation) {
            this.capability = capability;
            this.implementation = implementation;
        }

        public static Provider from(Capability<BooleanCapability> cap, NonNullSupplier<BooleanCapability> impl) {
            return new Provider(cap, LazyOptional.of(impl));
        }

        @Nonnull
        @Override
        public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
            return implementation.cast();
        }

        @Override
        public CompoundNBT serializeNBT() {
            AtomicReference<CompoundNBT> tag = new AtomicReference<>(new CompoundNBT());
            implementation.resolve().ifPresent(itemHandler -> {
                tag.set(itemHandler.serializeNBT());
            });
            return tag.get();
        }

        @Override
        public void deserializeNBT(CompoundNBT nbt) {
            implementation.resolve().ifPresent(itemHandler -> {
                itemHandler.deserializeNBT(nbt);
            });
        }

        public void invalidate() {
            implementation.invalidate();
        }
    }
}

Register:
    private void onLoad(FMLCommonSetupEvent event) {
        CapabilityManager.INSTANCE.register(BooleanCapability.class, new BooleanCapability.Storage(), new BooleanCapability.Factory());
    }