Why OSSA Treats Agents as First-Class Citizens

The software industry is experiencing a fundamental paradigm shift. For decades, we've designed systems with humans as the primary users. But in 2025, a new reality is emerging: agents are becoming the primary actors in software systems. This isn't just a trend—it's a transformation in how we architect, build, and operate software.

The Shift from Human-Centric to Agent-Centric Design

In April 2025, Janelle Teng, a partner at Bessemer Venture Partners, articulated this shift perfectly: "First-class citizens means agents are primary users of your system, not humans". This statement captures the essence of what's happening across the software industry.

Traditional software development has always centered on human interaction: graphical user interfaces, human-readable error messages, visual feedback loops. But when agents become the primary users, these assumptions break down. Agents don't need buttons—they need APIs. They don't need visual dashboards—they need structured data formats. They don't need tooltips—they need machine-readable schemas.

Teng's research demonstrates that companies redesigning their systems with agents as first-class citizens see dramatic improvements in automation capabilities, integration speed, and system scalability. The message is clear: treating agents as an afterthought is no longer viable.

What Does "First-Class Citizen" Actually Mean?

In programming, a "first-class citizen" is an entity that supports all operations generally available to other entities. When we say agents are first-class citizens, we mean:

• Direct Access: Agents interact with systems directly, not through human-mediated interfaces
• Full Capabilities: Agents have access to all system operations, not a limited subset
• Native Support: Systems are designed from the ground up with agents in mind
• Equal Priority: Agent needs are prioritized alongside (or above) human needs in design decisions

This isn't about adding a "bot API" to an existing human-centric system. It's about rethinking the entire architecture with agents as the primary actors.

Industry Validation: How Tech Leaders Are Embracing Agent-First Design

Major technology companies are already making this transition. Google's recent work on the Agent Development Kit (ADK) exemplifies this shift. In their article on "Architecting Efficient Context-Aware Multi-Agent Framework for Production", Google engineers describe how they've built context as a first-class system.

Google's approach demonstrates several critical principles:

1. Context Management as Infrastructure: Instead of treating context as a feature, it's foundational infrastructure
2. Multi-Agent Coordination: Systems designed for multiple agents working together, not single-agent scenarios
3. Production-Ready Architecture: Enterprise-grade patterns for agent deployment and orchestration

This isn't experimental research—this is production architecture from one of the world's largest technology companies. The agent-first future isn't coming; it's already here.

How OSSA Enables First-Class Agent Treatment

The Open Standard for Agents (OSSA) was designed from day one with agents as first-class citizens. Here's how:

1. Manifest-Driven Identity

Every OSSA agent has a manifest.json file that defines its identity, capabilities, and requirements. This isn't documentation for humans—it's machine-readable metadata that allows:

• Automatic Discovery: Systems can discover agents and their capabilities programmatically
• Dynamic Composition: Agents can be combined based on their declared capabilities
• Version Management: Systems can handle multiple agent versions simultaneously
• Dependency Resolution: Agents declare their requirements; systems provide them

2. Structured Communication Protocols

OSSA defines standardized protocols for agent-to-agent and agent-to-system communication:

{
  "protocols": {
    "input": "structured-json",
    "output": "structured-json",
    "errors": "machine-readable"
  }
}

This ensures agents can communicate reliably without human intervention.

3. Single-File Simplicity

While other specifications require complex multi-file structures, OSSA uses a single manifest file. This makes agents:

• Easy to Deploy: Copy one file, and the agent is fully described
• Simple to Validate: One file to check for compliance
• Fast to Process: Minimal I/O overhead for agent discovery
• Human-Readable: Developers can still understand agent capabilities

4. Runtime-Agnostic Design

OSSA doesn't prescribe how to run agents. Whether you're using Docker, Kubernetes, serverless functions, or bare metal, OSSA agents work the same way. This flexibility is crucial for first-class citizenship—agents shouldn't be locked into specific execution environments.

OSSA vs. Agent Spec: Why Simplicity Wins

The academic community has also recognized the need for agent standardization. The Agent Spec (arXiv:2510.04173), a collaborative effort from 19 researchers, proposes a comprehensive framework for agent definitions.

However, complexity creates barriers to adoption. Agent Spec requires:

• Multiple configuration files
• Complex dependency graphs
• Extensive boilerplate code
• Specialized tooling for validation

OSSA takes a different approach: maximum capability with minimum complexity.

Both specs recognize agents as first-class citizens, but OSSA makes it practical for real-world adoption. A 19-author specification demonstrates academic rigor; a single-file manifest demonstrates production pragmatism.

The Path Forward

Treating agents as first-class citizens isn't just about technical architecture—it's about recognizing a fundamental shift in how software systems operate. As Janelle Teng's research shows, companies that embrace this shift early gain significant competitive advantages.

OSSA provides the foundation for this agent-first future:

• Standardized manifests enable automatic agent discovery and composition
• Structured protocols allow reliable agent-to-agent communication
• Simple specifications reduce barriers to adoption
• Runtime agnostic design ensures flexibility across deployment environments

The transformation has begun. Major technology companies like Google are architecting production systems with agents at the center. The question isn't whether your systems will need to support agents as first-class citizens—it's whether you'll be ready when that becomes the default expectation.

Get Started Today

Ready to build agent-first systems? Here's how to start:

1. Review the OSSA Specification: Understand how manifests enable first-class agent treatment
2. Examine Example Agents: See how real-world agents implement OSSA patterns
3. Build Your First Agent: Create a simple OSSA-compliant agent and see how it integrates
4. Join the Community: Share your experiences and learn from others building agent-first systems

The future of software is agent-first. OSSA makes that future accessible today.

---

References:

1. Teng, J. (2025). "AI Agents as First-Class Citizens in Software Development". Bessemer Venture Partners.

2. Google Developers. (2025). "Architecting Efficient Context-Aware Multi-Agent Framework for Production".

3. Multi-author Collaboration. (2024). "Agent Spec: A Specification for Agent Definitions". arXiv:2510.04173.