Building Production-Ready Coding Agents with Cognitora

npm install @inngest/agent-kit @cognitora/sdk zod
# or
pip install agentkit cognitora anthropic

export ANTHROPIC_API_KEY="your-anthropic-key"
export COGNITORA_API_KEY="your-cognitora-key"

import { Cognitora } from '@cognitora/sdk';

const cognitora = new Cognitora({
  apiKey: process.env.COGNITORA_API_KEY,
});

// Create a persistent session for our agent's workspace
const session = await cognitora.sessions.create({
  language: 'bash',
  name: 'coding-agent-workspace',
});

console.log(`Session created: ${session.id}`);

import { createTool } from '@inngest/agent-kit';
import { z } from 'zod';

const createOrUpdateFilesTool = createTool({
  name: 'createOrUpdateFiles',
  description: 'Create or update multiple files in the workspace. Use this for writing code files, configuration, tests, etc.',
  parameters: z.object({
    files: z.array(
      z.object({
        path: z.string().describe('Relative file path (e.g., "src/app.ts")'),
        content: z.string().describe('Complete file content'),
      })
    ),
  }),
  handler: async ({ files }) => {
    try {
      // Write files to Cognitora session
      await Promise.all(
        files.map(async (file) => {
          await cognitora.sessions.files.write(session.id, {
            path: file.path,
            content: file.content,
          });
        })
      );

      return {
        success: true,
        message: `Successfully created/updated ${files.length} file(s): ${files.map(f => f.path).join(', ')}`,
      };
    } catch (error) {
      return {
        success: false,
        error: `Failed to write files: ${error.message}`,
      };
    }
  },
});

const readFilesTool = createTool({
  name: 'readFiles',
  description: 'Read contents of one or more files from the workspace',
  parameters: z.object({
    paths: z.array(z.string()).describe('Array of file paths to read'),
  }),
  handler: async ({ paths }) => {
    try {
      const contents = await Promise.all(
        paths.map(async (path) => {
          const content = await cognitora.sessions.files.read(session.id, path);
          return { path, content };
        })
      );

      return {
        success: true,
        files: contents,
      };
    } catch (error) {
      return {
        success: false,
        error: `Failed to read files: ${error.message}`,
      };
    }
  },
});

const executeCodeTool = createTool({
  name: 'executeCode',
  description: 'Execute code in the workspace (Python, Node.js, or Bash). Use for running the application, checking if code works, or quick tests.',
  parameters: z.object({
    language: z.enum(['python', 'javascript', 'bash']).describe('Programming language'),
    code: z.string().describe('Code to execute'),
    networking: z.boolean().optional().describe('Enable network access (default: false)'),
  }),
  handler: async ({ language, code, networking = false }) => {
    try {
      const result = await cognitora.codeInterpreter.execute({
        sessionId: session.id,
        code,
        language,
        networking,
      });

      return {
        success: !result.error,
        stdout: result.data?.outputs?.find(o => o.type === 'stdout')?.data || '',
        stderr: result.data?.outputs?.find(o => o.type === 'stderr')?.data || '',
        error: result.error,
        executionTime: result.data?.executionTime,
      };
    } catch (error) {
      return {
        success: false,
        error: `Execution failed: ${error.message}`,
      };
    }
  },
});

const runTerminalTool = createTool({
  name: 'runTerminal',
  description: 'Run terminal commands in the workspace. Use for npm install, running tests, linting, git operations, etc. Remember to use non-interactive flags (-y, --yes).',
  parameters: z.object({
    command: z.string().describe('Shell command to execute'),
  }),
  handler: async ({ command }) => {
    try {
      const result = await cognitora.codeInterpreter.execute({
        sessionId: session.id,
        code: command,
        language: 'bash',
        networking: true, // Often needed for package installs
      });

      return {
        success: !result.error,
        output: result.data?.outputs?.find(o => o.type === 'stdout')?.data || '',
        error: result.data?.outputs?.find(o => o.type === 'stderr')?.data || '',
      };
    } catch (error) {
      return {
        success: false,
        error: `Command failed: ${error.message}`,
      };
    }
  },
});

import { createAgent, createNetwork, anthropic } from '@inngest/agent-kit';

const codingAgent = createAgent({
  name: 'Cognitora Coding Agent',
  description: 'An autonomous coding agent powered by Cognitora sandboxes',
  
  system: `You are an expert coding agent that helps users build, debug, and improve software projects.

You have access to a secure, isolated Cognitora sandbox where you can:
- Create and modify files
- Execute code (Python, JavaScript/Node.js, Bash)
- Run terminal commands (npm, pip, git, etc.)

IMPORTANT GUIDELINES:
1. Always think step-by-step before acting
2. When running terminal commands, use non-interactive flags (-y, --yes, --no-input)
3. Test your code after writing it to ensure it works
4. If you encounter errors, analyze them carefully and fix the issues
5. Create comprehensive solutions, not just partial implementations

When you complete the task, respond with:
<task_complete>
Brief summary of what was accomplished
</task_complete>`,

  model: anthropic({
    model: 'claude-3-5-sonnet-latest',
    max_tokens: 8192,
  }),

  tools: [
    createOrUpdateFilesTool,
    readFilesTool,
    executeCodeTool,
    runTerminalTool,
  ],
});

const network = createNetwork({
  name: 'coding-agent-network',
  agents: [codingAgent],
  maxIter: 15, // Maximum iterations before stopping

  // Router determines when the agent should stop
  defaultRouter: ({ network }) => {
    const isComplete = network?.state.kv.has('task_complete');
    
    if (isComplete) {
      console.log('✅ Task completed!');
      return undefined; // Stop iteration
    }

    return codingAgent; // Continue with agent
  },
});

// Add lifecycle hook to detect completion
codingAgent.lifecycle = {
  onResponse: async ({ result, network }) => {
    const lastMessage = result.content[result.content.length - 1];
    
    if (lastMessage?.type === 'text' && lastMessage.text.includes('<task_complete>')) {
      // Extract summary
      const summary = lastMessage.text.match(/<task_complete>([\s\S]*?)<\/task_complete>/)?.[1]?.trim();
      network?.state.kv.set('task_complete', summary);
    }

    return result;
  },
};

async function main() {
  const userPrompt = process.argv.slice(2).join(' ') || 
    'Create a React Todo app with TypeScript, add unit tests, and run them';

  console.log(`🤖 Starting agent with prompt: "${userPrompt}"\n`);

  try {
    const result = await network.run(userPrompt);
    const summary = result.state.kv.get('task_complete');

    console.log('\n' + '='.repeat(60));
    console.log('TASK SUMMARY');
    console.log('='.repeat(60));
    console.log(summary);
    console.log('='.repeat(60));

    // Download the generated project
    console.log('\n📦 Downloading project files...');
    const files = await cognitora.sessions.files.list(session.id);
    
    for (const file of files) {
      const content = await cognitora.sessions.files.read(session.id, file.path);
      // Save to local filesystem
      await fs.writeFile(file.path, content);
    }

    console.log(`✅ Downloaded ${files.length} files to current directory`);
  } catch (error) {
    console.error('❌ Agent failed:', error);
  } finally {
    // Cleanup: delete session
    await cognitora.sessions.delete(session.id);
    console.log('\n🧹 Session cleaned up');
  }
}

main();

node agent.js "Create a FastAPI REST API for a todo list with SQLite database. \
Include CRUD endpoints, data validation with Pydantic, and pytest unit tests. \
After creating, run the tests to verify everything works."

🤖 Starting agent with prompt...

--- Iteration 1 ---
🔧 Tool: createOrUpdateFiles
   Creating: main.py, models.py, database.py, test_api.py, requirements.txt

--- Iteration 2 ---
🔧 Tool: runTerminal
   Command: pip install -r requirements.txt
   ✅ Installed fastapi, uvicorn, sqlalchemy, pytest

--- Iteration 3 ---
🔧 Tool: executeCode (Python)
   Running: python main.py (health check)
   ✅ Server initialization successful

--- Iteration 4 ---
🔧 Tool: runTerminal
   Command: pytest test_api.py -v --cov
   ✅ 12 tests passed, 95% coverage

--- Iteration 5 ---
✅ Task Complete!

=============================================================
TASK SUMMARY
=============================================================
Created a production-ready FastAPI Todo application with:

✅ RESTful API with CRUD endpoints
  - POST /todos - Create new todo
  - GET /todos - List all todos
  - GET /todos/{id} - Get specific todo
  - PUT /todos/{id} - Update todo
  - DELETE /todos/{id} - Delete todo

✅ SQLite database with SQLAlchemy ORM
✅ Pydantic models for request/response validation
✅ Comprehensive pytest test suite (12 tests, 95% coverage)
✅ All tests passing

Files created:
- main.py (185 lines)
- models.py (42 lines)
- database.py (28 lines)
- test_api.py (156 lines)
- requirements.txt (5 packages)

The API is ready for deployment!
=============================================================

// Upload buggy codebase
await cognitora.sessions.files.upload(session.id, {
  files: [
    { path: 'app.py', content: buggyCode },
    { path: 'test_app.py', content: testCode },
  ],
});

// Run the agent
await network.run(`
  The tests are failing. Debug the code, identify the issues, 
  fix them, and verify all tests pass.
`);

await network.run(`
  Refactor this codebase to:
  1. Follow PEP 8 style guidelines
  2. Add type hints throughout
  3. Extract duplicate code into reusable functions
  4. Add docstrings to all public functions
  5. Ensure all existing tests still pass
`);

await network.run(`
  Generate comprehensive documentation:
  1. Add inline comments to complex logic
  2. Create a README.md with setup instructions and API documentation
  3. Generate API documentation using Swagger/OpenAPI
  4. Add usage examples for each endpoint
`);

// Good: Let the agent learn from errors
handler: async ({ code }) => {
  try {
    const result = await cognitora.execute({ code });
    return {
      success: true,
      output: result.stdout,
    };
  } catch (error) {
    return {
      success: false,
      error: error.message, // Return to agent for correction
    };
  }
}

// Clean up sessions when done
try {
  await network.run(prompt);
} finally {
  await cognitora.sessions.delete(session.id);
  console.log('Session cleaned up');
}

import { RateLimiter } from 'limiter';

const limiter = new RateLimiter({
  tokensPerInterval: 10,
  interval: 'minute',
});

// Before each agent run
await limiter.removeTokens(1);

const result = await cognitora.codeInterpreter.execute({
  code,
  language,
  timeout: 30000, // 30 second maximum
});

let totalCredits = 0;

const executeCodeTool = createTool({
  // ... tool definition
  handler: async ({ code, language }) => {
    const result = await cognitora.execute({ code, language });
    
    // Track usage
    totalCredits += result.data?.creditsUsed || 0;
    console.log(`Credits used: ${result.data?.creditsUsed}, Total: ${totalCredits}`);
    
    return result;
  },
});

import winston from 'winston';

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'agent.log' }),
  ],
});

// Log all tool calls
codingAgent.lifecycle = {
  onToolCall: async ({ tool, parameters }) => {
    logger.info('Tool called', {
      tool: tool.name,
      parameters,
      timestamp: new Date().toISOString(),
    });
  },
};

const codingAgent = createAgent({
  // ... existing config
  mcpServers: [
    {
      name: 'github',
      transport: {
        type: 'sse',
        url: 'http://localhost:3000/mcp/github',
      },
    },
  ],
});

const backendAgent = createAgent({ /* backend specialist */ });
const frontendAgent = createAgent({ /* frontend specialist */ });
const testingAgent = createAgent({ /* testing specialist */ });

const network = createNetwork({
  agents: [backendAgent, frontendAgent, testingAgent],
  router: intelligentRouter, // Route tasks to appropriate agent
});

const deployTool = createTool({
  name: 'deploy',
  handler: async ({ target }) => {
    // Request human approval
    const approved = await requestApproval(`Deploy to ${target}?`);
    
    if (!approved) {
      return { success: false, error: 'Deployment cancelled by user' };
    }
    
    // Proceed with deployment
    return await deployApplication(target);
  },
});