Why is passing warn=false when making the ABM not an option...?

First, thanks for pointing out warn, I had overlooked that so far. However, it doesn't solve the problem, as it only turns off some of the checks (those for type concreteness, mutability, and velocity type). The check that's bringing me up short (:pos as second argument) is not affected by it.

I appreciate the defensive programming on display with these functions, but like I said I'm not sure they're still necessary, at least not in that form? Also, the use of warn seems a bit inconsistent.

Lastly, I think my situation (needing NoSpaceAgent as well as GridAgent) is well within the realms of the expectable, and should be provided for without having to turn off default behaviour?

function do_checks(::Type{A}, space::S, warn::Bool) where {A<:AbstractAgent,S<:SpaceType}
    if warn
        isbitstype(A) &&
        @warn "AgentType is not mutable. You probably haven't used `@agent`!"
    end
    (any(isequal(:id), fieldnames(A)) && fieldnames(A)[1] == :id) ||
    throw(ArgumentError("First field of Agent struct must be `id` (it should be of type `Int`)."))
    fieldtype(A, :id) <: Integer ||
    throw(ArgumentError("`id` field in Agent struct must be of type `Int`."))
    if space !== nothing
        space_type = typeof(space)
        if warn && !(any(isequal(:pos), fieldnames(A)) && fieldnames(A)[2] == :pos)
            @warn "Second field of Agent struct should be `pos` when using a space."
        elseif any(isequal(:pos), fieldnames(A))
            # Check `pos` field in A has the correct type
            pos_type = fieldtype(A, :pos)
            if space_type <: GraphSpace && !(pos_type <: Integer)
                throw(ArgumentError("`pos` field in Agent struct must be of type `Int` when using GraphSpace."))
            elseif space_type <: GridSpace && !(pos_type <: NTuple{D,Integer} where {D})
                throw(ArgumentError("`pos` field in Agent struct must be of type `NTuple{Int}` when using GridSpace."))
            elseif space_type <: ContinuousSpace || space_type <: ContinuousSpace
                if !(pos_type <: NTuple{D,<:AbstractFloat} where {D})
                    throw(ArgumentError("`pos` field in Agent struct must be of type `NTuple{<:AbstractFloat}` when using ContinuousSpace."))
                end
            end
        end
        if warn && space_type <: ContinuousSpace &&
            any(isequal(:vel), fieldnames(A)) &&
            !(fieldtype(A, :vel) <: NTuple{D,<:AbstractFloat} where {D})
            @warn "`vel` field in Agent struct should be of type `NTuple{<:AbstractFloat}` when using ContinuousSpace."
        end
    end
end

My suggestion would be this. This converts the ArgumentError about the missing :pos into a @warn (which can be silenced), and only carries out the :pos-related checks if we actually have a spatial agent type.

(Note that there is a line near the bottom with a duplicate check for space_type <: ContinuousSpace. I'm not sure whether the second check is supposed to check for a different space type, or whether it's superfluous?)

What do you think?

yes, I agree. (You'll open a PR I assume)

Working on it 👍

Could you give me a quick feedback on the duplicate ContinuousSpace check above? (Here in the current code.) This seems like something that should be fixed, but I'm not sure what the original intention was.

oh that's just a mistake

The proposed solution of adding the NoSpaceAgents to a special pos e.g. 1,1 causes a following problen: If you use add_agent! it checks for space being occupied. Is there a way to circumvent it?

What problems would you encounter if you simply had a vector of these extra "no-space-agents" as a model property? The normal model agents are the ones living in space, and you have another agent container in one of the model properties.

What problems would this make for you?

We still haven't resolved how to handle "no space agents" and "normal agents" together in one model, primarily because so far I haven't seen a concrete problem with just making these extra agents a model property.