La Chiesa di Sant’Agnese Vergine e Martire è annessa al Cimitero, che, nel 1867 il Comune di Cantalupo edificò, dopo averla acquistata insieme al terreno ad essa circostante.
Incerta è la data della sua costruzione: nel 1702 apparteneva alla famiglia Manfredi che la passò alla famiglia Martelli.
Ha un’ unica navata, con campanile a vela. Ha un solo Altare a stucco, dietro il quale è posto il dipinto raffigurante la Vergine tra le nuvole in una gloria di Angeli mentre tiene in braccio il Bambino nudo e con le braccia aperte. Ai suoi piedi, inginocchiati, con la testa inclinata, sono i Santi Francesco e Agnese; l’uno con le braccia al petto e le stimmate in evidenza, l’altra con le mani unite in preghiera. Ai piedi della Santa l’agnello e la palma del martirio.
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