Automata

Generates code by leveraging an LLM agent (GPT-4 via OpenAI API) that has access to a symbol graph and vector-embedded codebase. The agent uses a builder-pattern configuration system to customize model parameters, tools, and reasoning strategies. It performs semantic search over code embeddings to retrieve relevant context before generation, enabling the agent to write code that aligns with existing project patterns and architecture without requiring manual context injection.

Implements a dual-layer search system combining dense vector embeddings (for semantic similarity) with a symbol graph (for structural relationships). Code is embedded using an embedding model, stored in a vector database, and indexed alongside a symbol graph that tracks class hierarchies, function definitions, and dependencies. Search queries are embedded and matched against the vector store, with results ranked by semantic similarity and optionally filtered by symbol relationships, enabling developers to find relevant code without exact keyword matching.

Implements an abstraction layer for LLM providers that currently focuses on OpenAI (GPT-4, GPT-3.5) but is designed to support multiple providers. The abstraction defines a common interface for model invocation, parameter configuration, and response handling. Agents are configured with a specific model provider and parameters, allowing model swapping without changing agent logic.

Automatically retrieves relevant code context for agent reasoning by combining symbol graph queries and semantic search over embeddings. When an agent needs to reason about code, the system retrieves related symbols, their definitions, dependencies, and documentation without requiring explicit context specification. This enables agents to make informed decisions based on actual codebase structure rather than hallucinated or generic code patterns.

Processes Python source code to generate dense vector embeddings at multiple granularities (file-level, function-level, class-level) using an embedding model. The pipeline parses Python code into an AST, extracts symbols and documentation, generates embeddings for each unit, and stores them in a vector database alongside metadata (file path, line numbers, symbol type). This enables semantic search and context retrieval for code generation tasks.

Implements an autonomous agent system using an LLM (GPT-4) as the reasoning engine that can invoke a registry of specialized tools to accomplish tasks. The agent uses a builder-pattern configuration to define available tools, model parameters, and reasoning strategies. Tools include Python code execution, symbol search, file I/O, and documentation generation. The agent reasons about which tools to invoke in sequence, handles tool outputs, and iterates until task completion or failure.

Provides a Python interpreter tool that allows agents to execute arbitrary Python code in a controlled environment for testing, validation, and exploration. The tool captures stdout/stderr, execution results, and exceptions, returning structured output to the agent. This enables agents to test generated code, validate hypotheses, and iteratively refine solutions based on execution feedback.

Builds a directed graph representing Python code structure, where nodes are symbols (classes, functions, modules) and edges represent relationships (inheritance, imports, calls, definitions). The graph is constructed by parsing Python ASTs and extracting symbol definitions and references. Agents can query the graph to understand code dependencies, find symbol definitions, trace call chains, and navigate the codebase structure without loading entire files.

Implements a flexible configuration system using the builder pattern that allows declarative specification of agent parameters, model selection, tool registry, and system settings. Configurations are defined in YAML/JSON and loaded at runtime, enabling different agent configurations for different tasks without code changes. The builder pattern allows progressive construction of complex configurations with sensible defaults and validation.

Generates comprehensive documentation by analyzing code structure (via symbol graph and AST parsing) and using an LLM to create natural language descriptions of modules, classes, and functions. The system extracts docstrings, type hints, and code structure, then generates missing or enhanced documentation. Generated documentation is embedded and indexed for semantic search, creating a searchable knowledge base of the codebase.

Provides a testing and evaluation framework that measures agent performance on code generation tasks, tool accuracy, and overall system effectiveness. The framework includes regression tests, benchmarks, and evaluation metrics (success rate, code quality, execution time). Tests are defined declaratively and can be run against different agent configurations to compare performance.

Provides a comprehensive CLI that exposes all Automata functionality including agent execution, code search, indexing, configuration management, and evaluation. The CLI uses a command hierarchy (e.g., `automata agent run`, `automata search code`) and supports both interactive and batch modes. Configuration can be specified via CLI flags or configuration files.