The Future of Agent Coordination: Intents, Skills, and Why Applets Are the New Programs

On multiagent systems, persistent agents, and the evolution of human-computer interaction

By Joe Martinez

---

The first wave of AI assistants operate as isolated conversations. You open ChatGPT, ask a question, get an answer, close the tab. Every interaction starts fresh. There's no continuity, no persistent understanding, no accumulated capability.

This is the command-line era of AI: powerful, but disconnected.

We're building toward something different: agents that persist, coordinate, and accumulate capability over time. This post explains the architectural patterns we're developing and why we think skills—not prompts—are the programs of the future.

---

The Problem With Isolated Agents

Current AI tools are session-based. Each conversation is independent. The agent doesn't remember previous sessions, doesn't coordinate with other agents, and loses all context when you close the window.

This creates several problems:

1. Lost learning: Every helpful correction you provide, every preference you express, every workflow refinement you make—it all vanishes. The next session starts at zero.

2. Context re-establishment: Complex tasks require extensive context setup. You spend the first ten minutes of every session re-explaining who you are, what you're working on, and what you need.

3. No coordination: If you use multiple AI tools (which everyone does), each operates in isolation. There's no shared understanding, no coordinated action, no unified context.

4. No composition: You can't build on previous work. Each session produces output, but that output doesn't become capability. You're always starting over.

---

Intent Passing: How Agents Talk to Each Other

The first piece of the coordination puzzle is intent passing: how agents communicate what they're trying to accomplish.

Traditional API calls pass data: "here's the input, give me the output." This works for simple, well-defined operations.

Agent coordination requires passing intents: "here's what I'm trying to accomplish, here's the context, use your judgment."

The difference is profound:

Data passing: "Send an email with subject 'Meeting Follow-up' and body 'Thanks for your time today.'"

Intent passing: "Follow up on today's meeting with Sarah. The tone should be warm but professional. Reference the key decisions we made. I'll be seeing her at the conference next week, so set up future conversation."

Intent passing delegates judgment. The receiving agent interprets the intent in context, makes appropriate decisions, and executes accordingly.

This requires:

• Shared context: Both agents need access to relevant background
• Trust boundaries: The calling agent specifies what latitude the receiving agent has
• Outcome reporting: The receiving agent reports what it actually did, not just success/failure

We've built intent passing protocols that let agents delegate to each other without losing context or control. The orchestrating agent expresses high-level intent; specialized agents handle execution details.

---

Skills: The Programs of the Future

Here's our core thesis: skills are the new programs.

For sixty years, programming has meant writing explicit instructions in formal languages. Specify exactly what the computer should do, step by step, branch by branch.

AI changes this. Now you can specify what you want accomplished, and the model determines how to accomplish it. The "program" becomes a description of the desired outcome, not a prescription of the exact steps.

We call these skills: reusable specifications of outcomes that agents can execute.

A skill includes:

• Outcome description: What should be true when the skill completes
• Context requirements: What information the agent needs
• Quality criteria: How to evaluate success
• Example traces: Past executions showing good outcomes

Think of skills as programs where the runtime is an LLM rather than a CPU. Instead of:

def send_meeting_followup(meeting, recipient):
    subject = f"Follow-up: {meeting.title}"
    body = generate_body(meeting.notes, meeting.decisions)
    email.send(to=recipient, subject=subject, body=body)

You have:

skill: meeting_followup
outcome: |
  Recipient receives a professional follow-up email that:
  - Thanks them for their time
  - Summarizes key decisions made
  - Notes any action items for either party
  - Sets appropriate tone based on relationship
context_required:
  - meeting_notes
  - recipient_relationship
  - pending_action_items
quality_criteria:
  - Tone matches relationship formality
  - All decisions mentioned
  - Clear next steps if applicable

The skill specifies what, not how. The agent figures out how given the context.

---

Applets: Composable Skill Bundles

If skills are individual programs, applets are applications: bundles of related skills that work together.

Consider an "Executive Assistant" applet:

• Meeting prep skill: Generates briefing docs before meetings
• Follow-up skill: Sends appropriate follow-ups after meetings
• Scheduling skill: Handles calendar coordination
• Briefing skill: Produces morning summaries

These skills share context (understanding of relationships, priorities, communication preferences) and coordinate with each other (the follow-up skill references what the meeting prep skill prepared).

Applets are how capability accumulates. As you use the Executive Assistant applet:

• It learns your meeting preparation preferences
• It refines its understanding of relationship dynamics
• It improves follow-up quality based on feedback
• It builds a model of your priorities and communication style

This learning is retained across sessions. The applet gets better at being your executive assistant over time.

---

Persistent Agents: Always-On Capability

Session-based AI requires explicit activation. You open the tool when you need it.

Persistent agents are always running. They:

• Monitor relevant events (new emails, calendar changes, document updates)
• Prepare proactively (brief for upcoming meetings, flag potential issues)
• Act autonomously where authorized (simple responses, routine scheduling)
• Escalate appropriately when human judgment is needed

The shift from session to persistence changes everything.

Session-based: "AI, draft a response to this email."

Persistent: The agent already drafted the response when the email arrived. You review, approve with a single click, move on.

This requires robust autonomy boundaries. Persistent agents need clear understanding of:

• What actions they can take autonomously
• When they should prepare options for human review
• When they must escalate and wait for explicit direction

We're building permission frameworks that let users configure autonomy levels by domain, relationship, and risk level. Low-stakes routine tasks get high autonomy. High-stakes novel situations require human involvement.

---

The Human-Agent Interface

If agents are persistent, coordinating, and accumulating capability, how do humans interact with them?

The command-line paradigm (type a prompt, get a response) doesn't fit. Neither does the traditional GUI paradigm (explicit controls for every action).

We're developing what we call intent-driven interfaces. Instead of I/O (input command, output result), users express intents and agents figure out how to accomplish them.

The interface elements:

• Intent capture: Expressing what you want accomplished, often in context (while viewing a document, while in a meeting, while reading email)
• Confidence display: Showing the agent's certainty about what you want and how to accomplish it
• Approval gates: Checkpoints where humans confirm direction before consequential actions
• Outcome review: Visibility into what agents actually did and why

The metaphor isn't "assistant that follows instructions." It's closer to "team member who understands goals and uses judgment."

---

Compaction and Communication

As agents accumulate context and capability, they generate enormous amounts of information. Every decision trace, every user interaction, every piece of feedback—it all adds up.

This creates a challenge: how do you keep agents fast and focused while preserving valuable accumulated knowledge?

We're developing context compaction techniques:

• Distillation: Compressing detailed histories into essential patterns
• Hierarchical storage: Recent/important context is immediately accessible; historical context is available but requires retrieval
• Forgetting: Intentionally dropping low-value context to maintain focus

Similarly, when agents coordinate with each other, they need to communicate efficiently. Passing full context for every request is expensive and slow.

Communication protocols define:

• What context is shared by default vs. requested on-demand
• How to summarize complex states for coordination purposes
• When to establish persistent shared context vs. transient communication

These might seem like implementation details, but they're fundamental to building agents that scale—both in capability and in number of coordinated agents.

---

What We're Building Toward

The vision:

Applets as the new apps: Instead of opening different applications for different tasks, you have specialized skill bundles that work together with shared context.

Persistent capability: Agents that know you, remember context, and improve over time—not conversation bots that forget everything between sessions.

Intent-driven interaction: Express what you want; agents figure out how to accomplish it.

Coordinated delegation: Orchestrating agents that break down complex goals and delegate to specialized agents, while maintaining coherent context and appropriate human oversight.

This is a fundamental shift in how humans work with computers. For sixty years, we've adapted to computers: learning their languages, using their interfaces, working within their constraints.

Now computers are finally capable of adapting to us: understanding our intents, working within our context, using judgment to accomplish our goals.

We're building the infrastructure to make this real.

---

This is part of a series on agent architecture at Context. Learn more at context.inc