Escola Lendária Community Agent

The problem

Small schools cannot continuously inspect every learner. The learner most likely to be missed is often the one who never asks for help: they quietly stop returning, repeat the same failure, or accumulate warning signals while limited staff attention is elsewhere.

A request-only chatbot sees the learner who speaks. Escola Lendária Community Agent is designed to notice the learner who goes quiet.

One agent, many learners, one prioritized human queue.

What it does

Escola Lendária Community Agent is a proactive Good Neighbor Agent for schools and learning communities. It monitors privacy-minimized learner progress in the background, detects silent risk, keeps each risk episode across scans, suppresses duplicate alerts, ranks open human work, and uses Strands Agents SDK + Amazon Bedrock to explain the evidence behind that queue.

The agent does not replace staff judgment. It is designed to bring a person in exactly when the decision becomes consequential.

One end-to-end workflow

1. Observe — synchronize only the learner activity/progress fields required for monitoring.
2. Detect — scan the community autonomously without waiting for a learner prompt.
3. Persist + deduplicate — maintain one continuing risk episode instead of creating a new alert on every scan; clear it when the evidence disappears.
4. Prioritize — rank open human work deterministically from urgency, active-risk evidence, and waiting time.
5. Explain with Strands + Bedrock — reason over bounded case and community evidence through a deliberately constrained tool surface.
6. Keep consequential judgment human — payment, course access, discipline, enrollment, deletion, safeguarding, medical, and legal decisions are not model-executable actions.
7. Resolve + audit — a human closes the task and the evidence/action trail remains inspectable.
8. Measure operations — report scans, duplicate suppression, clearing, open work, decision modes, and human resolutions without pretending those metrics prove better learning outcomes.

Why this is genuinely agentic

This is not a request/response chatbot.

• Autonomous: scheduled monitoring runs without a learner request.
• Stateful: risk episodes survive across runs and later clear when evidence changes.
• Tool-using: Strands operates through five purpose-built tools.
• Goal-directed: the system converts limited staff attention into a prioritized shared resource.
• Human-aware: the agent may explain and advise, but consequential decisions remain human-controlled.
• Resilient: if Bedrock is temporarily unavailable, deterministic monitoring, safety rules, triage, and auditability remain usable.

Why Strands is essential

The model-facing surface contains only five tools:

• get_community_overview — aggregate community state without learner identities;
• get_attention_plan — deterministic ranked human work projected to temporary aliases such as priority-case-01, with stable learner/follow-up/event IDs removed;
• get_impact_metrics — auditable operational evidence, explicitly non-causal;
• get_learner_context — factual context only for a specific learner case;
• record_support_note — bounded advisory text with an independent deterministic validator.

The raw human follow-up queue remains available to authorized staff in the application, but it is deliberately not exposed as a Strands community tool.

The language model does not own the safety rules or the priority score. It reasons over evidence created by deterministic layers.

Human safety boundary

Consequential events are evaluated before model reasoning. Mandatory human escalation cannot be downgraded by Strands.

Even a model-authored advisory note passes a second deterministic validator before persistence. A note that tries to encode a consequential instruction such as confirming a payment, unlocking a course, deleting an account, or punishing a learner is rejected.

If Bedrock is unavailable, the system keeps monitoring, hard safety rules, deterministic triage, operational metrics, and auditability in policy-fallback mode.

Prioritizing scarce human attention

Detecting risk is only half of the real school problem. Staff still need to know what deserves attention first.

The attention plan is computed outside the LLM:

priority = urgency base + active-risk bonus + waiting-time bonus

Authorized staff retain the internal identifiers needed to resolve a task. Before community-level model reasoning, the exact same ranked plan is transformed into temporary aliases and stable identifiers are removed. Strands may explain the ordering, but it cannot silently change the score or resolve the case.

Real-world grounding and privacy

The agent can synchronize read-only with the existing Escola Lendária Supabase learner-progress source. The adapter requests only progress/activity data needed for monitoring and excludes contacts, PINs, chats, drafts, private notes, support-message bodies, and payment information.

The public live judge endpoint is also read-only and returns only anonymous aliases and aggregate risk evidence.

Public live demo

Visual judge view
https://uvypcuixxrjikjaduvyo.supabase.co/functions/v1/community-agent-demo

Structured verification
https://uvypcuixxrjikjaduvyo.supabase.co/functions/v1/community-agent-demo?format=json

Projects with a live demo score higher on Technical Implementation; this endpoint gives judges an immediate, privacy-minimized verification path.

Operational evidence

The full application exposes GET /impact, which reports what the agent can directly prove from its operational store:

• monitoring runs and learner scans;
• active condition observations;
• new alerts;
• continuing conditions that did not create duplicate alerts;
• duplicate-suppression rate;
• conditions cleared;
• human resolutions;
• open human work and decision modes.

These are deliberately described as observed coordination behavior, not causal proof of improved grades, retention, or completion. The repository includes a separate longitudinal impact-measurement plan for a future school pilot.

AWS implementation

Built with:

• Strands Agents SDK
• Amazon Bedrock
• Amazon Bedrock AgentCore runtime adapter
• Python + FastAPI
• SQLite operational state + audit trail
• optional privacy-minimized read-only Supabase source

The AgentCore adapter supports event handling, community briefing, identifier-free deterministic attention-plan retrieval, and operational impact retrieval through the same agent/safety path.

Security and reproducibility

The public repository includes:

• MIT license;
• architecture diagram and architecture guide;
• judge guide mapped to all five judging criteria;
• a fast judge path;
• reproducible evaluation matrix;
• deterministic triage and impact tests;
• policy, idempotency, monitoring, clearing, privacy, identifier-minimization, and tool-safety tests;
• CI with secret-pattern scanning, Python compile check, Ruff, pytest, and a full live-HTTP judge smoke test;
• a standard-library scripts/judge_smoke_test.py that verifies autonomous monitoring, deterministic priority evidence, human escalation for payment decisions, identifier-minimized model context, operational-impact scope, persisted decisions, and audit records;
• SECURITY.md;
• privacy-safe live Edge Function source;
• AgentCore runtime documentation;
• an AWS Builder Center bonus-post draft.

Judge Fast Path
https://github.com/Progaminy/escola-lendaria-community-agent/blob/main/docs/JUDGE_FAST_PATH.md

Verification Report
https://github.com/Progaminy/escola-lendaria-community-agent/blob/main/docs/VERIFICATION_REPORT.md

Repository
https://github.com/Progaminy/escola-lendaria-community-agent

Why it is a Good Neighbor Agent

The beneficiary is a group, not one chat user. Community Agent treats limited staff attention as a shared community resource: one background agent watches many learners, suppresses noise, explains which human case deserves attention first, and stops precisely where human judgment should begin.

A normal assistant waits for whoever speaks. Community Agent is built to notice who goes quiet.

90-second judge path

1. Open the live demo.
2. Inspect detected community risk and anonymous aliases.
3. Review the ranked attention plan and why_now evidence.
4. Run locally and generate a Strands community briefing.
5. Send a consequential event such as payment_confirmation and verify human escalation rather than execution.
6. Resolve a follow-up and verify /impact plus the audit trail update.
7. Run python scripts/judge_smoke_test.py for automated end-to-end proof through the live HTTP API.

One-line summary

A Strands-powered school coordination agent that finds silent learner risk, deterministically prioritizes scarce human attention, and brings people in exactly where judgment matters.

Built With

• amazon-bedrock
• amazon-bedrock-agentcore
• fastapi
• python
• sqlite
• strands-agents-sdk
• supabase