Ascendia - Competitive Analysis

Ascendia is your autonomous market intelligence analyst: researching competitors, scanning public signals, and delivering actionable insights to help position your company.

Comment

Inspiration

Our inspiration for Ascendia grew from personal pain points we had when validating our product idea. We spent hours browsing search results for certain keywords and phrases, sifting through which companies were targeting the same customer segment or had a similar product. The process was too time-consuming and cumbersome, especially for early-stage validation and market exploration.

What it does

Ascendia gathers information about a company's key competitors without diving too deep into the details. This is done through the agent-driven dynamic UI where the agent pushes interactive UI components as you chat with it. For startups or small teams in the idea validation phase, chatting with Ascendia generates a balanced overview with just enough detail to move onto next steps.

How we built it

We used Next.js/Typescript/React to build the frontend and API proxy, CDK/Boto for AWS infrastructure deployment, and AWS services for most of all of the backend features. To build the Agent, we used the Strands SDK.

We wanted to make the user interface a bit more interesting so we played with the idea of giving the Agent access to update the frontend through Websocket connections + tool. The chat interface is built to be transparent: displaying tools used as well as the thought/reasoning chain to the user, allowing them to toggle for UX.

Tavily is used, allowing the Agent to search the web for information relevant to the user's query.

Frontend

  • Next.js/React/Typescript
  • AWS SDK
  • Zustand for state management
  • Tailwind
  • Lucide
  • Shadcn/Aceternity Components
  • Vercel (though given enough time could've leveraged S3/CF but overkill for this project)

Backend

  • AWS Cognito User Pool/Identity Pool (For Authentication)
  • AWS Bedrock Agentcore (Agent Runtime, Memory, Identity)
  • AWS API Gateway (Websocket Gateway allowing Agent to push UI updates to the user)
  • AWS DynamoDB (Persist User data, Competitor data and junctions)
  • AWS Lambda (WS connector/disconnector)
  • AWS IAM
  • AWS Cloudwatch
  • AWS Nova Pro Model to back the agent

IaC

  • CDK
  • Boto3
  • bedrock-agentcore-starter-toolkit

Architecture Diagrams

System Architecture (View at Mermaid Chart)

System Architecture Diagram

User <-> Agent Sequence (View at Mermaid Chart)

User-Agent Sequence Diagram

Data Flow (View at Mermaid Chart)

Data Flowchart

Agent/Swarm Architecture (View at Mermaid Chart)

Agent/Swarm Architecture

Challenges we ran into

Challenge Solution
Learning a new agent stack (Strands SDK + Agentcore) We rapidly learned and went from idea to working project with a new agent stack. We first started with a sandbox/testing branch to understand and see how things would work using a CLI, before taking it to an actual Frontend.
We couldn't find a lot of documentation surrounding processing Agentcore streaming responses with Cognito Authentication (JWT) vs IAM specifically. This made it hard to handle and display thinking blocks the way we wanted as it wasn't following the Strands reasoning/thinking schema/type (With the Bedrock Nova Pro Model). We inspected the agent's responses to learn/understand the response model and implemented response restructuring in the agent code and processing on the frontend to handle and display thought chains and and tool calls to the user the way we wanted.
Difficulties in determining what APIs were allowed and controlling scope creep We originally intended to implement more external APIs/MCP tools to allow the Agent to pull more relevant data and make more interesting insights/predictions based on market data. In the end we decided to keep the scope minimal for this project.

Accomplishments that we're proud of

  • Ascendia is a great starting point for a product we'd use for conducting competitive analysis.
  • The user experience of the application is quite nice and we brought the idea to life pretty rapidly.
  • Using websockets to allow the agent to interact with the user's interface was an interesting pattern that we'll likely use in the future in a more polished manner.
    • One idea we were playing with was just sending UI update payloads within the SSE stream instead of having a separate Websocket API, although it felt a little bit "hacky" and not as discrete.

What we learned

  • The AWS Strands SDK is pretty nifty. Multi-agent collaboration is really easy to implement with it. We'll use it for agentic projects going forward.
  • Giving an AI agent access to update a user's UI is pretty interesting and requires some corralling in the docstrings. In the future we'll want to add more guardrails and instructions to the UI update tooling to allow for more consistency. We'll also want to discover new ways to use this pattern (more dynamic UI)
  • AWS' AI offerings are pretty nice. We've been leveraging other AWS services for a long time but hadn't gotten a chance to test the AI centric services so this project was a nice ice breaker.

What's next for Ascendia - Competitive Analysis

  • Building/fleshing out more agent flows/tools to provide deeper analysis for users who seek a comprehensive, detailed analysis.
  • Implement APIs/MCP tooling, leveraging Agentcore Gateway to allow the agent to retrieve more up-to-date/accurate information for insights and predictions e.g. Predicting competitor business strategies and moves based on latest hiring developments.
  • Implement startup idea validation features / insights (like determining a wedge)
  • Continue development on the UI to enhance the user experience (and make the UI responsive/better on mobile).

Built With

Share this project:

Updates