Luna — Autonomous Networking Agent

Tell Luna who you need to meet. It discovers and verifies the right people, finds credible connection paths, prepares outreach, and gets meetings booked—with your approval before taking action.

Comment

Inspiration

Professional networking still requires too much manual work. Finding the right person is only the beginning. You search across platforms, investigate their background, figure out whether someone in your network can introduce you, write the outreach, follow up, check calendars, and finally schedule a meeting.

I wanted to explore a different model: instead of giving people another networking search tool or chatbot, what if you could simply tell an agent who you need to meet and why, and let it handle the workflow?

That became Luna — an autonomous networking agent designed for professionals across tech, startups, and business, including founders, developers, product people, builders, and operators.

The goal is simple:

Tell Luna who you need to meet. It handles the rest.

What it does

Luna turns one networking goal into a multi-step workflow.

For example:

Find me a technical cofounder in Toronto actively building AI agents. Find the strongest person I can realistically meet and help me get introduced.

From that request, Luna can:

  1. Discover relevant people using GitHub and X.
  2. Rank candidates using source-grounded evidence.
  3. Search Google Contacts, Gmail, and Slack for credible connection signals.
  4. Determine whether a genuine warm introduction path can be verified.
  5. If no credible warm path exists, say so instead of inventing one and offer the strongest candidates for direct outreach.
  6. Prepare personalized outreach.
  7. Require explicit human approval before sending email.
  8. Check Google Calendar availability.
  9. Require approval again before creating a calendar event.
  10. Execute the approved action and help turn the original networking goal into a real meeting.

Luna currently integrates with GitHub, X, Slack, Google Contacts, Gmail, and Google Calendar.

How I built it

I separated Luna into a user-facing application and an autonomous agent backend.

The web interface was built with Lovable and uses Supabase for authentication and user/profile data. Users can create an account, complete their profile, connect supported services, and interact with Luna through the web application.

The core agent was built using the Strands Agents SDK. Strands provides the agent loop and tool orchestration that allow Luna to reason about a networking goal, decide which tools are needed, use their results, and continue through a multi-step workflow.

The agent is powered by Amazon Bedrock and deployed on Amazon Bedrock AgentCore Runtime.

The request path is:

Lovable Web App → Amazon API Gateway → AWS Lambda → Amazon Bedrock AgentCore Runtime → Strands Agent → Amazon Bedrock → External Tools

I implemented individual tools for GitHub, X, Google Contacts, Gmail, Google Calendar, and Slack. Rather than giving the model unrestricted ability to perform consequential actions, sending email and creating calendar events use explicit approval boundaries.

Supporting AWS infrastructure includes:

  • Amazon DynamoDB for asynchronous jobs, pending approvals, provider tokens, and application state.
  • AWS Secrets Manager for OAuth credentials and secrets.
  • AWS IAM for controlled access between services.
  • Amazon CloudWatch / AgentCore observability for runtime monitoring and debugging.
  • AWS Lambda + API Gateway as the browser-safe API and asynchronous bridge between the frontend and the agent.

This architecture keeps the web interface separate from the autonomous reasoning and execution layer running on AWS.

Challenges we ran into

One of the biggest challenges was making Luna perform real work reliably rather than simply generate convincing text.

A networking agent must distinguish between something it can infer and something it has actually verified. If Luna cannot find evidence of a relationship between two people, it must not claim that a warm introduction exists. I therefore designed a fallback where Luna still returns strong candidates but explicitly reports that it could not verify a credible warm path.

Another challenge was consequential actions. I did not want an autonomous agent sending emails or creating meetings simply because the model decided to. I implemented persistent approval actions so Luna can prepare an action, stop, request human approval, and execute only after receiving a valid approval.

I also encountered infrastructure challenges. Agent workflows can take longer than API Gateway's synchronous request window, so I implemented an asynchronous job architecture using AWS Lambda and DynamoDB: the frontend starts a job, receives a job ID, and polls for the completed agent response.

OAuth across multiple providers was another major part of the build. Google, GitHub, X, and Slack each required secure authentication flows, token handling, and user-scoped connections.

Accomplishments that I'm proud of

The biggest accomplishment is that Luna is not just a conversational prototype — it performs real multi-app workflows.

It can discover candidates from live sources, investigate connection signals across a user's network, distinguish verified evidence from unsupported assumptions, prepare outreach, enforce approval boundaries, interact with Gmail and Calendar, and execute real actions.

I also built and ran an 8-test end-to-end reliability evaluation suite covering:

  1. Multi-source candidate discovery
  2. Relationship verification
  3. No-hallucination fallback
  4. Slack grounding
  5. Gmail approval gate
  6. Approved Gmail execution
  7. Calendar approval gate
  8. Approved calendar execution

Result: 8/8 tests passed — a 100% pass rate across this evaluation suite.

The final calendar test resulted in a real event being created, demonstrating that the workflow can move from natural-language intent to verified external action.

What I learned

The biggest lesson was that building an agent is very different from building a chatbot.

The difficult part is not producing a good response. It is deciding when the agent should reason, when it should call a tool, what evidence it can trust, when it must admit that evidence is missing, and where autonomous execution should stop for human approval.

I also learned how important deterministic boundaries are around probabilistic AI systems. Luna can autonomously discover, compare, rank, and reason, but consequential actions such as sending an email or creating a meeting are separated behind explicit approval gates.

Using Strands with Amazon Bedrock AgentCore made it possible to treat Luna as an actual deployed agent with tools and workflows rather than simply adding an LLM response endpoint to a web application.

What's next for Luna — Autonomous Networking Agent

The next step is to expand Luna from individual networking requests into a persistent networking agent that understands a user's professional goals and can help maintain relationships over time.

Future work includes better candidate ranking, richer relationship signals, follow-up workflows, additional professional platforms, improved agent memory, and deeper reliability evaluation.

The long-term vision is for professional networking to move from:

search → tabs → messages → calendars → manual follow-up

to:

tell Luna the outcome you want → review the important decisions → meet the right person.

Built With

Share this project:

Updates

Submission history