Aether

Inspiration

Every support and employee-experience system we've used shares the same failure pattern: an agent follows a script until the moment a conversation goes off it, and then it either loops, escalates blindly, or hands off to a human who has to start from zero. The handoff is where most of the damage happens. The customer repeats everything they already said, the human gets no context, and whatever the AI figured out along the way disappears the moment the ticket closes.

We kept coming back to one question: what if the agent wasn't a fixed flowchart at all? What if it behaved less like software and more like an organism, growing the exact specialists a moment needs and dissolving them once they're no longer useful, predicting when a human should step in before the conversation actually breaks down, and getting smarter every time it survives a hard case instead of forgetting the moment the session ends. That question became Aether.

What it does

Aether is a self-orchestrating agent organism built for Freshworks Agent Studio and MCP. A lightweight Core agent reads intent, emotion, and complexity as a session unfolds and spawns exactly the specialists that moment needs (billing, technical, empathy, risk, policy), then dissolves them again once they've done their job. Four capabilities came out of that core idea:

• Dynamic Agent Graph : specialists are born, collaborate, and dissolve live, visible as an evolving graph rather than a hidden pipeline.
• Predictive Warm Handoff : Aether reads rising emotional load 30 to 60 seconds before a human is needed and prepares a full briefing (summary, actions taken, risk flags, a suggested opening line) so the human never starts cold.
• Continuous Skill Learning : every hard session gets distilled into a versioned, reusable skill committed to Skills Memory over MCP, so the organism gets measurably better at the next one.
• Full Observability : agent graph state, emotion, confidence, and organism health are visible live, not buried in a report nobody reads until Monday.

How we built it

The prototype is a single self-contained HTML, CSS, and JavaScript application, with no framework underneath it. Every interaction, the agent graph visualization, the emotion meter, the predictive handoff countdown, the skills library, was hand-built rather than assembled from a component kit. That constraint forced real discipline about what the interface actually needed to communicate versus what was just decoration.

We designed around Freshworks Agent Studio as the orchestration layer and MCP as the connective tissue between specialists and their tools, so every specialist reaches ledgers, crash logs, and policy data through the same uniform interface rather than a pile of bolted-on integrations. The agent graph itself is modeled as live state: nodes spawn with a confidence score, route data to each other along visible edges, and dissolve when their task resolves, which is what makes the graph feel like it's actually rewriting itself rather than animating a canned sequence.

The landing page and the prototype were built as companion pieces. The landing page tells the story of why this matters; the prototype proves the how, with real interactive screens instead of static mockups.

Challenges we ran into

Getting the predictive handoff to feel earned rather than arbitrary took the most iteration. It's easy to fire a "hand this off to a human" signal off a single angry message, but that produces false alarms constantly. We had to weight it against contact history, emotional trend over time, and whether the issue was something the system could actually resolve on its own, so the 30-to-60-second early warning reads as genuinely predictive instead of reactive.

Keeping the agent graph legible was the second big one. The moment more than two or three specialists are active at once, a naive graph turns into visual noise. We spent a lot of time on what to hide (raw reasoning traces, low-signal tool calls) versus what to surface (who's active, what they're confident about, how they connect), so the graph stays readable even as the organism itself gets more complex underneath.

What we learned

The hardest part of building an agentic system turned out to be less about model capability and more about legibility and trust: a system that silently reorganizes itself is unsettling no matter how good its decisions are, so we learned to treat visibility (the graph, the health score, the confidence numbers) as a first-class feature rather than a debugging afterthought. We also came away convinced that memory is the real differentiator. An agent that resolves a hard case and forgets it is doing the same expensive work over and over; an agent that turns that case into a reusable skill compounds in value every single session.

What's next for Aether

Deeper integration with live Freshworks Agent Studio workflows, real MCP tool execution in place of simulated calls, and expanding Skills Memory so skills learned in one organism can be shared across teams and sessions instead of staying scoped to a single deployment.

Built With

• agent
• agents
• ai
• canvas
• css
• customer
• experience
• freshworks
• generative
• html
• human-in-the-loop
• javascript
• langgraph
• mcp
• multi-agent
• orchestration
• rag
• real-time
• studio
• svg
• systems
• voice