argus

ARGUS — From competitor change to verified business action.

Comment

Inspiration

Competitive intelligence usually ends at the point where the real work begins.

A team may discover that a competitor has changed its pricing, launched a new feature, or altered its market position, but someone still has to verify the information, determine whether it matters, decide what the company should do, execute that response, and confirm that the action actually happened.

We wanted ARGUS to close that gap.

ARGUS already existed before this hackathon as an autonomous business-intelligence agent. Its original system could discover information, extract facts, verify evidence, detect contradictions, rank findings, and produce market intelligence using deterministic orchestration.

For the Agents for Humans Hackathon, we asked a different question:

What if ARGUS could move from verified intelligence to governed business action?

That became the Competitive Response Agent.

What it does

ARGUS turns a competitive change into a verified and governed business response.

In our demo scenario, competitor ApexAI offers a comparable plan at $69/month, compared with Northstar AI's $99/month Professional plan, while also offering an advanced analytics capability.

ARGUS processes the competitive signal and supplied evidence, verifies claims before they influence decisions, and then uses an AWS Strands Agent to reason about the business impact and determine appropriate responses.

The workflow is:

Competitive Signal → Evidence Verification → Business Impact Assessment → Response Selection → Governed Execution → Independent Verification → Audit Trail

ARGUS separates actions according to risk.

Safe internal actions, such as updating a sales battlecard or creating a pricing-review task, can proceed autonomously.

Consequential external actions are different. ARGUS can propose them, but a server-side policy boundary prevents execution until a human explicitly approves the action.

After execution, ARGUS independently checks the resulting state instead of assuming that an attempted action succeeded.

Our guiding principle is:

Autonomous where it's safe. Human-controlled where it matters. Verified afterward.

How we built it

The Competitive Response capability combines deterministic ARGUS intelligence with an AWS Strands Agents SDK reasoning layer.

Before the model reasons about a response, deterministic preprocessing prepares the competitive context and verifies the supplied evidence. Only verified intelligence is passed into the decision layer.

At the center is a real Strands Agent, using Google Gemini 2.5 Flash as its model provider.

The agent has two focused tools:

assess_impact

Evaluates the verified competitive intelligence to determine:

  • Pricing pressure
  • Feature gap
  • Commercial impact
  • Confidence
  • Business reasoning

propose_response_actions

Uses the impact assessment to select appropriate business responses.

Keeping the agent's tool surface focused allows the model to handle the part where reasoning adds the most value, while deterministic application code handles evidence preparation, authorization, execution policy, and verification.

Our optimized normal workflow completes the AWS Strands reasoning process in exactly three measured model turns.

The application uses:

  • AWS Strands Agents SDK for agent reasoning and tool orchestration
  • Google Gemini 2.5 Flash as the Strands model provider
  • Python + FastAPI for the backend
  • Next.js + React + TypeScript for the frontend
  • SQLAlchemy + SQLite for persistent application state

ARGUS records competitive signals, supporting evidence, verified claims, impact assessments, proposed actions, execution state, and audit events.

Human governance

One of our most important design decisions was not giving the model unrestricted execution authority.

ARGUS distinguishes between safe internal actions and consequential external actions.

Safe internal actions can proceed autonomously.

Consequential actions are forced into a:

PENDING_APPROVAL

state.

The Strands agent cannot bypass this restriction because the approval requirement is enforced outside the model layer by deterministic application policy.

A human must explicitly approve the action before the execution endpoint accepts it.

This makes human oversight part of the system architecture, rather than merely an instruction written into an LLM prompt.

Independent verification

We wanted ARGUS to distinguish between:

"The agent attempted an action."

and:

"The intended outcome actually exists."

After an action executes, ARGUS independently reads the resulting application state and verifies the outcome.

Only then does the action reach its verified completion state.

The complete lifecycle is recorded in an audit trail:

PROPOSED → AWAITING APPROVAL → APPROVED → EXECUTED → VERIFIED

This provides traceability across reasoning, governance, execution, and outcome verification.

Challenges we ran into

One of our biggest challenges was deciding where AI reasoning should end and deterministic control should begin.

Giving an agent more tools can make a system appear more autonomous, but it also gives probabilistic reasoning responsibility for operations that software can enforce more reliably.

We ultimately reduced the Competitive Response reasoning layer to two agent-visible tools and moved evidence preparation, authorization policy, execution boundaries, and post-execution verification outside the model loop.

Another challenge was preserving meaningful autonomy without sacrificing human control.

We solved this by classifying responses according to consequence:

  • Routine internal actions can proceed autonomously.
  • Consequential external actions require explicit human approval.

We also deliberately avoid a silent deterministic fallback when the configured model fails. A model failure should remain visible rather than being disguised as successful AI reasoning.

Accomplishments that we're proud of

We're particularly proud that ARGUS does not simply generate recommendations.

It creates a complete lifecycle around an AI decision:

Verified Evidence → Reasoning → Action → Governance → Execution → Verification → Auditability

The Competitive Response implementation uses a genuine AWS Strands Agent rather than simulating agent behavior entirely in application code.

We are also proud of:

  • The server-side policy boundary protecting consequential actions
  • Autonomous execution for safe internal responses
  • Explicit human approval for consequential responses
  • Independent verification after execution
  • Persistent lifecycle auditability
  • A focused Strands reasoning layer with only two agent-visible tools
  • Exactly three measured model turns in the optimized normal workflow

The backend currently passes 402 automated tests, alongside successful frontend type checking and production builds.

What we learned

Building ARGUS reinforced that useful business agents need more than an LLM and a collection of tools.

They need clear boundaries around:

  • What the model should decide
  • What software should enforce deterministically
  • What the agent can execute autonomously
  • What requires human authority
  • How the system determines whether an action actually succeeded

AWS Strands Agents gave us a clean way to make model reasoning and tool use part of the application while allowing the surrounding system to enforce deterministic governance.

We also learned that reducing an agent's tool surface can make the overall system stronger.

Instead of asking the model to orchestrate every mechanical operation, we use it for the two decisions where reasoning adds the most value:

  1. Understanding business impact
  2. Selecting the appropriate response

Everything around those decisions can then be made more predictable, auditable, and secure.

What's next for ARGUS

The hackathon version operates on a controlled Competitive Response workflow so that evidence, reasoning, policy enforcement, and execution can be evaluated reproducibly.

The next step is connecting this governed response layer more deeply with ARGUS's broader competitive-intelligence capabilities and real organizational systems.

This could allow verified competitive intelligence to trigger governed workflows across:

  • Sales
  • Product
  • Strategy
  • Marketing

while preserving the same approval and verification boundaries.

We also want to expand action adapters, improve evidence-quality assessment, and explore additional model providers through the provider flexibility offered by Strands.

The long-term goal is not an agent that simply watches competitors.

It is an agent that helps organizations:

Respond to change safely, quickly, and with evidence for every decision.

Built With

AWS Strands Agents SDK · Google Gemini 2.5 Flash · Python · FastAPI · Next.js · React · TypeScript · SQLAlchemy · SQLite · Tailwind CSS

Existing Work Disclosure

ARGUS existed before the hackathon as an autonomous business-intelligence agent.

The pre-hackathon ARGUS used deterministic orchestration for business-intelligence workflows including discovery, extraction, evidence verification, contradiction handling, analysis, ranking, and reporting.

For the Agents for Humans Hackathon, we developed the new AWS Strands Agents-powered Competitive Response capability, extending ARGUS from producing verified intelligence into reasoning about business impact, selecting responses, executing safe actions autonomously, governing consequential actions through human approval, and independently verifying execution outcomes.

Built With

Share this project:

Updates

Submission history