Job Scout Intel — Human-Controlled Career Agent

A Strands-powered career intelligence agent that watches job-market changes, investigates evidence, triages opportunities, and brings consequential decisions back to the human.

Comment

Inspiration

A serious job search creates an enormous amount of repetitive work: monitoring companies, checking new openings, tracking layoffs or hiring freezes, comparing roles against your actual experience, remembering what changed, and deciding what deserves attention.

I had already built Job Scout to handle deterministic job discovery, normalization, eligibility gates, fit scoring, and workflow state. For the Agents for Humans Hackathon, I wanted to solve the next problem: how can an agent do more of the repetitive research and judgment-heavy preparation without taking consequential career decisions away from the person?

That became Job Scout Intel.

Instead of building an autonomous application bot, I designed an agent that can watch, investigate, gather evidence, triage opportunities, remember what happened, and surface decisions — while deliberately stopping when human judgment is required.

What it does

Job Scout Intel adds an agentic intelligence layer on top of the existing deterministic Job Scout platform.

Users can create persistent natural-language Missions, such as watching a company for hiring freezes, layoffs, reorganizations, or meaningful changes in hiring activity.

The system can:

  • monitor governed external signals;
  • collect and preserve evidence with provenance;
  • create Investigations from that evidence;
  • generate Alerts when something materially changes;
  • triage job opportunities that survive deterministic hard gates;
  • compare opportunities against existing resume evidence;
  • produce structured DecisionPackets instead of unbounded chat responses;
  • persist durable RunReceipts and decision state;
  • surface the important decisions in a human review experience.

The human can then decide whether an opportunity is interesting, should be held, reviewed later, or dismissed.

The agent cannot submit an application, approve one for the user, override hard eligibility gates, or silently change canonical Fit, Gate, Priority, tracker, or application state.

That boundary is enforced in code rather than relying only on prompting.

How I built it

The new intelligence layer is built in Python using the Strands Agents SDK.

The architecture intentionally separates deterministic truth from agent reasoning:

  1. Existing Job Scout systems own discovery, eligibility, lifecycle, and canonical job-search state.
  2. A read-only adapter exposes only the information the intelligence layer needs.
  3. Deterministic filtering removes clearly blocked or already-resolved opportunities before model inference.
  4. Strands agents receive narrow, read-only tools for investigation and triage.
  5. Model output is validated into structured objects such as Evidence, Investigations, Alerts, DecisionPackets, and RunReceipts.
  6. Intel state is persisted independently using SQLite locally and PostgreSQL/Supabase for the production state plane.
  7. Human-facing surfaces present the evidence and decisions requiring attention.
  8. Separate write and action boundaries prevent the agent from crossing into autonomous application control.

For production-capable execution, I also integrated a bounded provider policy with Kilo as the primary route and OpenRouter as a retryable-infrastructure failover path. Amazon Bedrock AgentCore provides a managed AWS runtime and observability integration around the Strands investigation workflow without requiring the project to hand model authority over consequential user decisions.

The public repository includes a credential-free synthetic demo so judges can run the core Mission → Investigation → Evidence → Alert flow locally without access to my private job-search data or production credentials.

Challenges

The hardest part was not simply making an agent call tools. It was making the system trustworthy when connected to an existing real-world workflow.

Several challenges only became obvious after production exercise:

  • keeping the new agent layer from mutating deterministic Job Scout truth;
  • preventing tool-search loops from consuming the entire inference budget;
  • handling provider throttling and bounded failover;
  • reconciling local SQLite assumptions with the production Supabase/PostgreSQL state plane;
  • making long-running triage and Mission execution durable through asynchronous receipts;
  • maintaining authentication and privacy boundaries;
  • distinguishing implemented behavior from behavior that had actually been verified in production.

The production feedback loop became an important part of the project. I repeatedly deployed the system, observed failures under real conditions, converted those observations into bounded fixes, and strengthened the associated regression tests rather than treating the first successful deployment as the finish line.

Another major challenge was creating a public submission from a private job-search system. I built dedicated export and privacy-scanning tooling so the hackathon repository contains the relevant source code, architecture, tests, and synthetic judge path without exposing personal applications, recruiter communications, credentials, private tracker state, or employment records.

What I learned

The biggest lesson was that useful agent autonomy does not require unlimited authority.

Strands works especially well here because the model can dynamically investigate and select bounded tools while deterministic systems continue to own the facts and rules that should not be probabilistic.

I also learned how important durable evidence and receipts are. When agents run in the background, it is not enough to know that something happened. The system should preserve what was observed, what tools were used, which provider actually ran, what remains unresolved, and where the human needs to make the final decision.

Finally, production testing reinforced the difference between implemented, tested, deployed, and production-proven. I kept those states separate throughout the final hardening and documentation process rather than turning successful code paths into unsupported claims.

What's next

The architecture can extend beyond job searching to other professional workflows where agents should perform repetitive monitoring, research, comparison, and preparation while keeping consequential decisions with the person.

The core idea behind Job Scout Intel is simple:

Let the agent spend the attention. Let the human keep the authority.

Built With

Share this project:

Updates

Submission history